happstack-foundation-0.5.9.3: Glue code for using Happstack with acid-state, web-routes, reform, and HSP
Safe HaskellNone
LanguageHaskell2010

Happstack.Foundation

Description

happstack-foundation provides a type-safe environment for Haskell web development. It builds on top of:

  • happstack-server - an HTTP server
  • HSP - HTML Templating
  • web-routes - type-safe URL routing
  • reform - type-safe form composition and validation
  • acid-state - native Haskell persistent database

An example application can be found here:

http://patch-tag.com/r/mae/happstack/snapshot/current/content/pretty/happstack-foundation/examples/ControlV/Main.hs

A screencast can be found here:

http://www.youtube.com/watch?v=7Wmszk4wZxQ

happstack-foundation itself is not yet documented in the Happstack Crash Course. However, all of the components that it uses are:

http://www.happstack.com/docs/crashcourse/index.html

Synopsis

Configuration

data AcidConfig st where Source #

configuration information for our acid-state database

Constructors

AcidLocal :: (IsAcidic st, SafeCopy st, Typeable st) => Maybe FilePath -> st -> AcidConfig (AcidState st) 
AcidUsing :: st -> AcidConfig st 

data FoundationConf Source #

configuration for server

Constructors

FoundationConf 

Type Aliases

type FoundationT url acidState requestState m = XMLGenT (FoundationT' url acidState requestState m) Source #

the FoundationT monad

  • url - the type-safe URL route type
  • acidState - the type of the state value stored in acid-state
  • requestState - a per-request state value that the developer can getsetmodify
  • m - inner monad

see also: whereami, getRequestState, setRequestState, modifyRequestState, simpleApp

type FoundationT' url acidState requestState m = RouteT url (StateT (AppState url acidState requestState) (ServerPartT m)) Source #

similar to the FoundationT' type alias, but without the XMLGenT wrapper. This variant is most often used in class constraints.

type FoundationForm url acidState requestState m = Form (FoundationT url acidState requestState m) [Input] AppError [FoundationT url acidState requestState m XML] () Source #

FoundationForm is an alias for working with reform based Forms

FoundationT functions

whereami :: (Functor m, Monad m) => FoundationT url acidState requestState m url Source #

returns the decoded url from the Request

getRequestState :: (Functor m, MonadState (AppState url acidState requestState) m) => m requestState Source #

get the requestState value

setRequestState :: (Functor m, MonadState (AppState url acidState requestState) m) => requestState -> m () Source #

set the requestState value

modifyRequestState :: MonadState (AppState url acidState requestState) m => (requestState -> requestState) -> m () Source #

set the requestState value

HTML Template

defaultTemplate :: (Functor m, Monad m, XMLGenerator (FoundationT' url acidState requestState m), EmbedAsChild (FoundationT' url acidState requestState m) body, EmbedAsChild (FoundationT' url acidState requestState m) headers, XMLType (FoundationT' url acidState requestState m) ~ XML) => Text -> headers -> body -> FoundationT url acidState requestState m XML Source #

default page template

acid-state

class HasAcidState m st where Source #

HasAcidState provides a single method getAcidState which can be used to retrieve an AcidState handle from the current monad.

Methods

getAcidState :: m (AcidState st) Source #

Instances

Instances details
HasAcidState (FoundationT' url acid reqSt m) acidSt => HasAcidState (XMLGenT (FoundationT' url acid reqSt m)) acidSt Source # 
Instance details

Defined in Happstack.Foundation

Methods

getAcidState :: XMLGenT (FoundationT' url acid reqSt m) (AcidState acidSt) Source #

(Functor m, Monad m) => HasAcidState (FoundationT url (AcidState acidState) requestState m) acidState Source # 
Instance details

Defined in Happstack.Foundation

Methods

getAcidState :: FoundationT url (AcidState acidState) requestState m (AcidState acidState) Source #

query :: forall event m. (Functor m, MonadIO m, QueryEvent event, HasAcidState m (EventState event)) => event -> m (EventResult event) Source #

wrapper around query from acid-state

This variant automatically gets the AcidState handle from the monad

update :: forall event m. (Functor m, MonadIO m, UpdateEvent event, HasAcidState m (EventState event)) => event -> m (EventResult event) Source #

wrapper around update from acid-state

This variant automatically gets the AcidState handle from the monad

getAcidSt :: (Functor m, MonadState (AppState url acidState requestState) m) => m acidState Source #

running

simpleApp Source #

Arguments

:: (ToMessage a, PathInfo url, Monad m) 
=> (forall r. m r -> IO r)

function to flatten inner monad

-> FoundationConf

Conf to pass onto simpleHTTP

-> AcidConfig acidState

AcidState configuration

-> requestState

initial requestState value

-> url

default URL (ie, what does / map to)

-> Text

the base URL for the site as seen by the outside world (or, at least, by your openid provider) (e.g. "http://example.org:8000", no trailing slash)

-> (url -> FoundationT url acidState requestState m a)

handler

-> IO () 

run the application

starts the database, listens for requests, etc.

re-exports

class Typeable a => Data a where #

The Data class comprehends a fundamental primitive gfoldl for folding over constructor applications, say terms. This primitive can be instantiated in several ways to map over the immediate subterms of a term; see the gmap combinators later in this class. Indeed, a generic programmer does not necessarily need to use the ingenious gfoldl primitive but rather the intuitive gmap combinators. The gfoldl primitive is completed by means to query top-level constructors, to turn constructor representations into proper terms, and to list all possible datatype constructors. This completion allows us to serve generic programming scenarios like read, show, equality, term generation.

The combinators gmapT, gmapQ, gmapM, etc are all provided with default definitions in terms of gfoldl, leaving open the opportunity to provide datatype-specific definitions. (The inclusion of the gmap combinators as members of class Data allows the programmer or the compiler to derive specialised, and maybe more efficient code per datatype. Note: gfoldl is more higher-order than the gmap combinators. This is subject to ongoing benchmarking experiments. It might turn out that the gmap combinators will be moved out of the class Data.)

Conceptually, the definition of the gmap combinators in terms of the primitive gfoldl requires the identification of the gfoldl function arguments. Technically, we also need to identify the type constructor c for the construction of the result type from the folded term type.

In the definition of gmapQx combinators, we use phantom type constructors for the c in the type of gfoldl because the result type of a query does not involve the (polymorphic) type of the term argument. In the definition of gmapQl we simply use the plain constant type constructor because gfoldl is left-associative anyway and so it is readily suited to fold a left-associative binary operation over the immediate subterms. In the definition of gmapQr, extra effort is needed. We use a higher-order accumulation trick to mediate between left-associative constructor application vs. right-associative binary operation (e.g., (:)). When the query is meant to compute a value of type r, then the result type withing generic folding is r -> r. So the result of folding is a function to which we finally pass the right unit.

With the -XDeriveDataTypeable option, GHC can generate instances of the Data class automatically. For example, given the declaration

data T a b = C1 a b | C2 deriving (Typeable, Data)

GHC will generate an instance that is equivalent to

instance (Data a, Data b) => Data (T a b) where
    gfoldl k z (C1 a b) = z C1 `k` a `k` b
    gfoldl k z C2       = z C2

    gunfold k z c = case constrIndex c of
                        1 -> k (k (z C1))
                        2 -> z C2

    toConstr (C1 _ _) = con_C1
    toConstr C2       = con_C2

    dataTypeOf _ = ty_T

con_C1 = mkConstr ty_T "C1" [] Prefix
con_C2 = mkConstr ty_T "C2" [] Prefix
ty_T   = mkDataType "Module.T" [con_C1, con_C2]

This is suitable for datatypes that are exported transparently.

Minimal complete definition

gunfold, toConstr, dataTypeOf

Methods

gfoldl #

Arguments

:: (forall d b. Data d => c (d -> b) -> d -> c b)

defines how nonempty constructor applications are folded. It takes the folded tail of the constructor application and its head, i.e., an immediate subterm, and combines them in some way.

-> (forall g. g -> c g)

defines how the empty constructor application is folded, like the neutral / start element for list folding.

-> a

structure to be folded.

-> c a

result, with a type defined in terms of a, but variability is achieved by means of type constructor c for the construction of the actual result type.

Left-associative fold operation for constructor applications.

The type of gfoldl is a headache, but operationally it is a simple generalisation of a list fold.

The default definition for gfoldl is const id, which is suitable for abstract datatypes with no substructures.

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a #

Unfolding constructor applications

toConstr :: a -> Constr #

Obtaining the constructor from a given datum. For proper terms, this is meant to be the top-level constructor. Primitive datatypes are here viewed as potentially infinite sets of values (i.e., constructors).

dataTypeOf :: a -> DataType #

The outer type constructor of the type

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c a) #

Mediate types and unary type constructors.

In Data instances of the form

    instance (Data a, ...) => Data (T a)

dataCast1 should be defined as gcast1.

The default definition is const Nothing, which is appropriate for instances of other forms.

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a) #

Mediate types and binary type constructors.

In Data instances of the form

    instance (Data a, Data b, ...) => Data (T a b)

dataCast2 should be defined as gcast2.

The default definition is const Nothing, which is appropriate for instances of other forms.

gmapT :: (forall b. Data b => b -> b) -> a -> a #

A generic transformation that maps over the immediate subterms

The default definition instantiates the type constructor c in the type of gfoldl to an identity datatype constructor, using the isomorphism pair as injection and projection.

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r #

A generic query with a left-associative binary operator

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r #

A generic query with a right-associative binary operator

gmapQ :: (forall d. Data d => d -> u) -> a -> [u] #

A generic query that processes the immediate subterms and returns a list of results. The list is given in the same order as originally specified in the declaration of the data constructors.

gmapQi :: Int -> (forall d. Data d => d -> u) -> a -> u #

A generic query that processes one child by index (zero-based)

gmapM :: Monad m => (forall d. Data d => d -> m d) -> a -> m a #

A generic monadic transformation that maps over the immediate subterms

The default definition instantiates the type constructor c in the type of gfoldl to the monad datatype constructor, defining injection and projection using return and >>=.

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a #

Transformation of at least one immediate subterm does not fail

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> a -> m a #

Transformation of one immediate subterm with success

Instances

Instances details
Data Bool

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool #

toConstr :: Bool -> Constr #

dataTypeOf :: Bool -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) #

gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r #

gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool #

Data Char

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char #

toConstr :: Char -> Constr #

dataTypeOf :: Char -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) #

gmapT :: (forall b. Data b => b -> b) -> Char -> Char #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r #

gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char #

Data Double

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double #

toConstr :: Double -> Constr #

dataTypeOf :: Double -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) #

gmapT :: (forall b. Data b => b -> b) -> Double -> Double #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r #

gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double #

Data Float

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float #

toConstr :: Float -> Constr #

dataTypeOf :: Float -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) #

gmapT :: (forall b. Data b => b -> b) -> Float -> Float #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r #

gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float #

Data Int

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int #

toConstr :: Int -> Constr #

dataTypeOf :: Int -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) #

gmapT :: (forall b. Data b => b -> b) -> Int -> Int #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int #

Data Int8

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 #

toConstr :: Int8 -> Constr #

dataTypeOf :: Int8 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int8) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) #

gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 #

Data Int16

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 #

toConstr :: Int16 -> Constr #

dataTypeOf :: Int16 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int16) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) #

gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 #

Data Int32

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 #

toConstr :: Int32 -> Constr #

dataTypeOf :: Int32 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int32) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) #

gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #

Data Int64

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 #

toConstr :: Int64 -> Constr #

dataTypeOf :: Int64 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int64) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) #

gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #

Data Integer

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer #

toConstr :: Integer -> Constr #

dataTypeOf :: Integer -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) #

gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r #

gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer #

Data Natural

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural #

toConstr :: Natural -> Constr #

dataTypeOf :: Natural -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) #

gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r #

gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural #

Data Ordering

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering #

toConstr :: Ordering -> Constr #

dataTypeOf :: Ordering -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) #

gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering #

Data Word

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word #

toConstr :: Word -> Constr #

dataTypeOf :: Word -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) #

gmapT :: (forall b. Data b => b -> b) -> Word -> Word #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word #

Data Word8

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8 #

toConstr :: Word8 -> Constr #

dataTypeOf :: Word8 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word8) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8) #

gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 #

Data Word16

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 #

toConstr :: Word16 -> Constr #

dataTypeOf :: Word16 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word16) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) #

gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 #

Data Word32

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 #

toConstr :: Word32 -> Constr #

dataTypeOf :: Word32 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word32) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) #

gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 #

Data Word64

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 #

toConstr :: Word64 -> Constr #

dataTypeOf :: Word64 -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word64) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) #

gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r #

gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 #

Data Exp 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp -> c Exp #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp #

toConstr :: Exp -> Constr #

dataTypeOf :: Exp -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Exp) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp) #

gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r #

gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp #

Data Match 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match -> c Match #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Match #

toConstr :: Match -> Constr #

dataTypeOf :: Match -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Match) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match) #

gmapT :: (forall b. Data b => b -> b) -> Match -> Match #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r #

gmapQ :: (forall d. Data d => d -> u) -> Match -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match -> m Match #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match #

Data Clause 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Clause -> c Clause #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Clause #

toConstr :: Clause -> Constr #

dataTypeOf :: Clause -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Clause) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause) #

gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r #

gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Clause -> m Clause #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause #

Data Pat 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pat -> c Pat #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pat #

toConstr :: Pat -> Constr #

dataTypeOf :: Pat -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pat) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat) #

gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r #

gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat -> m Pat #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat #

Data Type 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type #

toConstr :: Type -> Constr #

dataTypeOf :: Type -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) #

gmapT :: (forall b. Data b => b -> b) -> Type -> Type #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r #

gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #

Data Dec 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dec -> c Dec #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dec #

toConstr :: Dec -> Constr #

dataTypeOf :: Dec -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Dec) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec) #

gmapT :: (forall b. Data b => b -> b) -> Dec -> Dec #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r #

gmapQ :: (forall d. Data d => d -> u) -> Dec -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dec -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dec -> m Dec #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec #

Data Name 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name #

toConstr :: Name -> Constr #

dataTypeOf :: Name -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) #

gmapT :: (forall b. Data b => b -> b) -> Name -> Name #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r #

gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #

Data FunDep 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep -> c FunDep #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDep #

toConstr :: FunDep -> Constr #

dataTypeOf :: FunDep -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunDep) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep) #

gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r #

gmapQ :: (forall d. Data d => d -> u) -> FunDep -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep #

Data InjectivityAnn 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InjectivityAnn #

toConstr :: InjectivityAnn -> Constr #

dataTypeOf :: InjectivityAnn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InjectivityAnn) #

gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r #

gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn #

Data Overlap 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap -> c Overlap #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overlap #

toConstr :: Overlap -> Constr #

dataTypeOf :: Overlap -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overlap) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap) #

gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r #

gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap #

Data ()

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> () -> c () #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c () #

toConstr :: () -> Constr #

dataTypeOf :: () -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ()) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ()) #

gmapT :: (forall b. Data b => b -> b) -> () -> () #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> () -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> () -> r #

gmapQ :: (forall d. Data d => d -> u) -> () -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> () -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> () -> m () #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> () -> m () #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> () -> m () #

Data ByteString 
Instance details

Defined in Data.ByteString.Lazy.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteString -> c ByteString #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteString #

toConstr :: ByteString -> Constr #

dataTypeOf :: ByteString -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteString) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteString) #

gmapT :: (forall b. Data b => b -> b) -> ByteString -> ByteString #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r #

gmapQ :: (forall d. Data d => d -> u) -> ByteString -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteString -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString #

Data TyVarBndr 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyVarBndr #

toConstr :: TyVarBndr -> Constr #

dataTypeOf :: TyVarBndr -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyVarBndr) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVarBndr) #

gmapT :: (forall b. Data b => b -> b) -> TyVarBndr -> TyVarBndr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r #

gmapQ :: (forall d. Data d => d -> u) -> TyVarBndr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBndr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBndr -> m TyVarBndr #

Data Void

Since: base-4.8.0.0

Instance details

Defined in Data.Void

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Void -> c Void #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Void #

toConstr :: Void -> Constr #

dataTypeOf :: Void -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Void) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Void) #

gmapT :: (forall b. Data b => b -> b) -> Void -> Void #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r #

gmapQ :: (forall d. Data d => d -> u) -> Void -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Void -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Void -> m Void #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void #

Data SpecConstrAnnotation

Since: base-4.3.0.0

Instance details

Defined in GHC.Exts

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpecConstrAnnotation -> c SpecConstrAnnotation #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpecConstrAnnotation #

toConstr :: SpecConstrAnnotation -> Constr #

dataTypeOf :: SpecConstrAnnotation -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpecConstrAnnotation) #

gmapT :: (forall b. Data b => b -> b) -> SpecConstrAnnotation -> SpecConstrAnnotation #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r #

gmapQ :: (forall d. Data d => d -> u) -> SpecConstrAnnotation -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpecConstrAnnotation -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation #

Data Version

Since: base-4.7.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Version -> c Version #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Version #

toConstr :: Version -> Constr #

dataTypeOf :: Version -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Version) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version) #

gmapT :: (forall b. Data b => b -> b) -> Version -> Version #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r #

gmapQ :: (forall d. Data d => d -> u) -> Version -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Version -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Version -> m Version #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version #

Data All

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All #

toConstr :: All -> Constr #

dataTypeOf :: All -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c All) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) #

gmapT :: (forall b. Data b => b -> b) -> All -> All #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r #

gmapQ :: (forall d. Data d => d -> u) -> All -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All #

Data Any

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any #

toConstr :: Any -> Constr #

dataTypeOf :: Any -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Any) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) #

gmapT :: (forall b. Data b => b -> b) -> Any -> Any #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r #

gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any #

Data Fixity

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity #

toConstr :: Fixity -> Constr #

dataTypeOf :: Fixity -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) #

gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r #

gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #

Data Associativity

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Associativity -> c Associativity #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Associativity #

toConstr :: Associativity -> Constr #

dataTypeOf :: Associativity -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Associativity) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Associativity) #

gmapT :: (forall b. Data b => b -> b) -> Associativity -> Associativity #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r #

gmapQ :: (forall d. Data d => d -> u) -> Associativity -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Associativity -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity #

Data SourceUnpackedness

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness #

toConstr :: SourceUnpackedness -> Constr #

dataTypeOf :: SourceUnpackedness -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) #

gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r #

gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness #

Data SourceStrictness

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness #

toConstr :: SourceStrictness -> Constr #

dataTypeOf :: SourceStrictness -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) #

gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r #

gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness #

Data DecidedStrictness

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness #

toConstr :: DecidedStrictness -> Constr #

dataTypeOf :: DecidedStrictness -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) #

gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r #

gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness #

Data WordPtr

Since: base-4.11.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WordPtr -> c WordPtr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WordPtr #

toConstr :: WordPtr -> Constr #

dataTypeOf :: WordPtr -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WordPtr) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WordPtr) #

gmapT :: (forall b. Data b => b -> b) -> WordPtr -> WordPtr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r #

gmapQ :: (forall d. Data d => d -> u) -> WordPtr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WordPtr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr #

Data IntPtr

Since: base-4.11.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntPtr -> c IntPtr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntPtr #

toConstr :: IntPtr -> Constr #

dataTypeOf :: IntPtr -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntPtr) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntPtr) #

gmapT :: (forall b. Data b => b -> b) -> IntPtr -> IntPtr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r #

gmapQ :: (forall d. Data d => d -> u) -> IntPtr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IntPtr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr #

Data IntSet 
Instance details

Defined in Data.IntSet.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntSet -> c IntSet #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntSet #

toConstr :: IntSet -> Constr #

dataTypeOf :: IntSet -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntSet) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntSet) #

gmapT :: (forall b. Data b => b -> b) -> IntSet -> IntSet #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntSet -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntSet -> r #

gmapQ :: (forall d. Data d => d -> u) -> IntSet -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IntSet -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntSet -> m IntSet #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntSet -> m IntSet #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntSet -> m IntSet #

Data EntryKind 
Instance details

Defined in Happstack.Server.FileServe.BuildingBlocks

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EntryKind -> c EntryKind #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c EntryKind #

toConstr :: EntryKind -> Constr #

dataTypeOf :: EntryKind -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c EntryKind) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c EntryKind) #

gmapT :: (forall b. Data b => b -> b) -> EntryKind -> EntryKind #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EntryKind -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EntryKind -> r #

gmapQ :: (forall d. Data d => d -> u) -> EntryKind -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> EntryKind -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EntryKind -> m EntryKind #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EntryKind -> m EntryKind #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EntryKind -> m EntryKind #

Data Browsing 
Instance details

Defined in Happstack.Server.FileServe.BuildingBlocks

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Browsing -> c Browsing #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Browsing #

toConstr :: Browsing -> Constr #

dataTypeOf :: Browsing -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Browsing) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Browsing) #

gmapT :: (forall b. Data b => b -> b) -> Browsing -> Browsing #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Browsing -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Browsing -> r #

gmapQ :: (forall d. Data d => d -> u) -> Browsing -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Browsing -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Browsing -> m Browsing #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Browsing -> m Browsing #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Browsing -> m Browsing #

Data Method 
Instance details

Defined in Happstack.Server.Internal.Types

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Method -> c Method #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Method #

toConstr :: Method -> Constr #

dataTypeOf :: Method -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Method) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Method) #

gmapT :: (forall b. Data b => b -> b) -> Method -> Method #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Method -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Method -> r #

gmapQ :: (forall d. Data d => d -> u) -> Method -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Method -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Method -> m Method #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Method -> m Method #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Method -> m Method #

Data Cookie 
Instance details

Defined in Happstack.Server.Internal.Cookie

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Cookie -> c Cookie #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Cookie #

toConstr :: Cookie -> Constr #

dataTypeOf :: Cookie -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Cookie) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cookie) #

gmapT :: (forall b. Data b => b -> b) -> Cookie -> Cookie #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cookie -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cookie -> r #

gmapQ :: (forall d. Data d => d -> u) -> Cookie -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Cookie -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Cookie -> m Cookie #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Cookie -> m Cookie #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Cookie -> m Cookie #

Data SameSite 
Instance details

Defined in Happstack.Server.Internal.Cookie

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SameSite -> c SameSite #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SameSite #

toConstr :: SameSite -> Constr #

dataTypeOf :: SameSite -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SameSite) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SameSite) #

gmapT :: (forall b. Data b => b -> b) -> SameSite -> SameSite #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SameSite -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SameSite -> r #

gmapQ :: (forall d. Data d => d -> u) -> SameSite -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SameSite -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SameSite -> m SameSite #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SameSite -> m SameSite #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SameSite -> m SameSite #

Data Boxed 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Boxed -> c Boxed #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Boxed #

toConstr :: Boxed -> Constr #

dataTypeOf :: Boxed -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Boxed) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Boxed) #

gmapT :: (forall b. Data b => b -> b) -> Boxed -> Boxed #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Boxed -> r #

gmapQ :: (forall d. Data d => d -> u) -> Boxed -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Boxed -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Boxed -> m Boxed #

Data Tool 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tool -> c Tool #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tool #

toConstr :: Tool -> Constr #

dataTypeOf :: Tool -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Tool) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tool) #

gmapT :: (forall b. Data b => b -> b) -> Tool -> Tool #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tool -> r #

gmapQ :: (forall d. Data d => d -> u) -> Tool -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tool -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tool -> m Tool #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tool -> m Tool #

Data SrcLoc 
Instance details

Defined in Language.Haskell.Exts.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcLoc -> c SrcLoc #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcLoc #

toConstr :: SrcLoc -> Constr #

dataTypeOf :: SrcLoc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcLoc) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcLoc) #

gmapT :: (forall b. Data b => b -> b) -> SrcLoc -> SrcLoc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcLoc -> r #

gmapQ :: (forall d. Data d => d -> u) -> SrcLoc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcLoc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcLoc -> m SrcLoc #

Data SrcSpan 
Instance details

Defined in Language.Haskell.Exts.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpan -> c SrcSpan #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpan #

toConstr :: SrcSpan -> Constr #

dataTypeOf :: SrcSpan -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpan) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpan) #

gmapT :: (forall b. Data b => b -> b) -> SrcSpan -> SrcSpan #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpan -> r #

gmapQ :: (forall d. Data d => d -> u) -> SrcSpan -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpan -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpan -> m SrcSpan #

Data SrcSpanInfo 
Instance details

Defined in Language.Haskell.Exts.SrcLoc

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcSpanInfo -> c SrcSpanInfo #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SrcSpanInfo #

toConstr :: SrcSpanInfo -> Constr #

dataTypeOf :: SrcSpanInfo -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SrcSpanInfo) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SrcSpanInfo) #

gmapT :: (forall b. Data b => b -> b) -> SrcSpanInfo -> SrcSpanInfo #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpanInfo -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SrcSpanInfo -> r #

gmapQ :: (forall d. Data d => d -> u) -> SrcSpanInfo -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SrcSpanInfo -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SrcSpanInfo -> m SrcSpanInfo #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpanInfo -> m SrcSpanInfo #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SrcSpanInfo -> m SrcSpanInfo #

Data Priority 
Instance details

Defined in System.Log

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Priority -> c Priority #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Priority #

toConstr :: Priority -> Constr #

dataTypeOf :: Priority -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Priority) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Priority) #

gmapT :: (forall b. Data b => b -> b) -> Priority -> Priority #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Priority -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Priority -> r #

gmapQ :: (forall d. Data d => d -> u) -> Priority -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Priority -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Priority -> m Priority #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Priority -> m Priority #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Priority -> m Priority #

Data URI 
Instance details

Defined in Network.URI

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URI -> c URI #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c URI #

toConstr :: URI -> Constr #

dataTypeOf :: URI -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c URI) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URI) #

gmapT :: (forall b. Data b => b -> b) -> URI -> URI #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URI -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URI -> r #

gmapQ :: (forall d. Data d => d -> u) -> URI -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> URI -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> URI -> m URI #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URI -> m URI #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URI -> m URI #

Data URIAuth 
Instance details

Defined in Network.URI

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URIAuth -> c URIAuth #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c URIAuth #

toConstr :: URIAuth -> Constr #

dataTypeOf :: URIAuth -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c URIAuth) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URIAuth) #

gmapT :: (forall b. Data b => b -> b) -> URIAuth -> URIAuth #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URIAuth -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URIAuth -> r #

gmapQ :: (forall d. Data d => d -> u) -> URIAuth -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> URIAuth -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> URIAuth -> m URIAuth #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URIAuth -> m URIAuth #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URIAuth -> m URIAuth #

Data ByteArray 
Instance details

Defined in Data.Primitive.ByteArray

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteArray -> c ByteArray #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteArray #

toConstr :: ByteArray -> Constr #

dataTypeOf :: ByteArray -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteArray) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteArray) #

gmapT :: (forall b. Data b => b -> b) -> ByteArray -> ByteArray #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteArray -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteArray -> r #

gmapQ :: (forall d. Data d => d -> u) -> ByteArray -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteArray -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteArray -> m ByteArray #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteArray -> m ByteArray #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteArray -> m ByteArray #

Data ModName 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModName -> c ModName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModName #

toConstr :: ModName -> Constr #

dataTypeOf :: ModName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName) #

gmapT :: (forall b. Data b => b -> b) -> ModName -> ModName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModName -> m ModName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName #

Data PkgName 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PkgName -> c PkgName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PkgName #

toConstr :: PkgName -> Constr #

dataTypeOf :: PkgName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PkgName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName) #

gmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r #

gmapQ :: (forall d. Data d => d -> u) -> PkgName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PkgName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName #

Data Module 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module #

toConstr :: Module -> Constr #

dataTypeOf :: Module -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) #

gmapT :: (forall b. Data b => b -> b) -> Module -> Module #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r #

gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module #

Data OccName 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccName #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccName #

toConstr :: OccName -> Constr #

dataTypeOf :: OccName -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OccName) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName) #

gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r #

gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccName #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName #

Data NameFlavour 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameFlavour -> c NameFlavour #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameFlavour #

toConstr :: NameFlavour -> Constr #

dataTypeOf :: NameFlavour -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameFlavour) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameFlavour) #

gmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r #

gmapQ :: (forall d. Data d => d -> u) -> NameFlavour -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NameFlavour -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour #

Data NameSpace 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameSpace -> c NameSpace #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSpace #

toConstr :: NameSpace -> Constr #

dataTypeOf :: NameSpace -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameSpace) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace) #

gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r #

gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace #

Data Loc 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc #

toConstr :: Loc -> Constr #

dataTypeOf :: Loc -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Loc) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc) #

gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r #

gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc #

Data Info 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Info -> c Info #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Info #

toConstr :: Info -> Constr #

dataTypeOf :: Info -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Info) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info) #

gmapT :: (forall b. Data b => b -> b) -> Info -> Info #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r #

gmapQ :: (forall d. Data d => d -> u) -> Info -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Info -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Info -> m Info #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info #

Data ModuleInfo 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleInfo #

toConstr :: ModuleInfo -> Constr #

dataTypeOf :: ModuleInfo -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo) #

gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo #

Data Fixity 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity #

toConstr :: Fixity -> Constr #

dataTypeOf :: Fixity -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) #

gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r #

gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #

Data FixityDirection 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection #

toConstr :: FixityDirection -> Constr #

dataTypeOf :: FixityDirection -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection) #

gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r #

gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection #

Data Lit 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lit -> c Lit #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lit #

toConstr :: Lit -> Constr #

dataTypeOf :: Lit -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Lit) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit) #

gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r #

gmapQ :: (forall d. Data d => d -> u) -> Lit -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Lit -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Lit -> m Lit #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Lit -> m Lit #

Data Bytes 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bytes -> c Bytes #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bytes #

toConstr :: Bytes -> Constr #

dataTypeOf :: Bytes -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bytes) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bytes) #

gmapT :: (forall b. Data b => b -> b) -> Bytes -> Bytes #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bytes -> r #

gmapQ :: (forall d. Data d => d -> u) -> Bytes -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bytes -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bytes -> m Bytes #

Data Body 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Body -> c Body #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Body #

toConstr :: Body -> Constr #

dataTypeOf :: Body -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Body) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body) #

gmapT :: (forall b. Data b => b -> b) -> Body -> Body #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r #

gmapQ :: (forall d. Data d => d -> u) -> Body -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Body -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Body -> m Body #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body #

Data Guard 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c Guard #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Guard #

toConstr :: Guard -> Constr #

dataTypeOf :: Guard -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Guard) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard) #

gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r #

gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Guard -> m Guard #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard #

Data Stmt 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt -> c Stmt #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stmt #

toConstr :: Stmt -> Constr #

dataTypeOf :: Stmt -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Stmt) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt) #

gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r #

gmapQ :: (forall d. Data d => d -> u) -> Stmt -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt #

Data Range 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Range -> c Range #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Range #

toConstr :: Range -> Constr #

dataTypeOf :: Range -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Range) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range) #

gmapT :: (forall b. Data b => b -> b) -> Range -> Range #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r #

gmapQ :: (forall d. Data d => d -> u) -> Range -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Range -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Range -> m Range #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range #

Data DerivClause 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClause -> c DerivClause #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivClause #

toConstr :: DerivClause -> Constr #

dataTypeOf :: DerivClause -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivClause) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivClause) #

gmapT :: (forall b. Data b => b -> b) -> DerivClause -> DerivClause #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r #

gmapQ :: (forall d. Data d => d -> u) -> DerivClause -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClause -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause #

Data DerivStrategy 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivStrategy #

toConstr :: DerivStrategy -> Constr #

dataTypeOf :: DerivStrategy -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivStrategy) #

gmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r #

gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy #

Data TypeFamilyHead 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead #

toConstr :: TypeFamilyHead -> Constr #

dataTypeOf :: TypeFamilyHead -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeFamilyHead) #

gmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypeFamilyHead -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead #

Data TySynEqn 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TySynEqn #

toConstr :: TySynEqn -> Constr #

dataTypeOf :: TySynEqn -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TySynEqn) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn) #

gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r #

gmapQ :: (forall d. Data d => d -> u) -> TySynEqn -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TySynEqn -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn #

Data Foreign 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Foreign -> c Foreign #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Foreign #

toConstr :: Foreign -> Constr #

dataTypeOf :: Foreign -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Foreign) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign) #

gmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r #

gmapQ :: (forall d. Data d => d -> u) -> Foreign -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Foreign -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign #

Data Callconv 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Callconv -> c Callconv #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Callconv #

toConstr :: Callconv -> Constr #

dataTypeOf :: Callconv -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Callconv) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv) #

gmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r #

gmapQ :: (forall d. Data d => d -> u) -> Callconv -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Callconv -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv #

Data Safety 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety -> c Safety #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Safety #

toConstr :: Safety -> Constr #

dataTypeOf :: Safety -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Safety) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety) #

gmapT :: (forall b. Data b => b -> b) -> Safety -> Safety #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r #

gmapQ :: (forall d. Data d => d -> u) -> Safety -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety -> m Safety #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety -> m Safety #

Data Pragma 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pragma -> c Pragma #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pragma #

toConstr :: Pragma -> Constr #

dataTypeOf :: Pragma -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pragma) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pragma) #

gmapT :: (forall b. Data b => b -> b) -> Pragma -> Pragma #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pragma -> r #

gmapQ :: (forall d. Data d => d -> u) -> Pragma -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pragma -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pragma -> m Pragma #

Data Inline 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Inline -> c Inline #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Inline #

toConstr :: Inline -> Constr #

dataTypeOf :: Inline -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Inline) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Inline) #

gmapT :: (forall b. Data b => b -> b) -> Inline -> Inline #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Inline -> r #

gmapQ :: (forall d. Data d => d -> u) -> Inline -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Inline -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Inline -> m Inline #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Inline -> m Inline #

Data RuleMatch 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleMatch -> c RuleMatch #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleMatch #

toConstr :: RuleMatch -> Constr #

dataTypeOf :: RuleMatch -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleMatch) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleMatch) #

gmapT :: (forall b. Data b => b -> b) -> RuleMatch -> RuleMatch #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleMatch -> r #

gmapQ :: (forall d. Data d => d -> u) -> RuleMatch -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleMatch -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleMatch -> m RuleMatch #

Data Phases 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Phases -> c Phases #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Phases #

toConstr :: Phases -> Constr #

dataTypeOf :: Phases -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Phases) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Phases) #

gmapT :: (forall b. Data b => b -> b) -> Phases -> Phases #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Phases -> r #

gmapQ :: (forall d. Data d => d -> u) -> Phases -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Phases -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Phases -> m Phases #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Phases -> m Phases #

Data RuleBndr 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleBndr -> c RuleBndr #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RuleBndr #

toConstr :: RuleBndr -> Constr #

dataTypeOf :: RuleBndr -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RuleBndr) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RuleBndr) #

gmapT :: (forall b. Data b => b -> b) -> RuleBndr -> RuleBndr #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleBndr -> r #

gmapQ :: (forall d. Data d => d -> u) -> RuleBndr -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleBndr -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleBndr -> m RuleBndr #

Data AnnTarget 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnTarget -> c AnnTarget #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnTarget #

toConstr :: AnnTarget -> Constr #

dataTypeOf :: AnnTarget -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnTarget) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnTarget) #

gmapT :: (forall b. Data b => b -> b) -> AnnTarget -> AnnTarget #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnTarget -> r #

gmapQ :: (forall d. Data d => d -> u) -> AnnTarget -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnTarget -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnTarget -> m AnnTarget #

Data SourceUnpackedness 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness #

toConstr :: SourceUnpackedness -> Constr #

dataTypeOf :: SourceUnpackedness -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) #

gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r #

gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness #

Data SourceStrictness 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness #

toConstr :: SourceStrictness -> Constr #

dataTypeOf :: SourceStrictness -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) #

gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r #

gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness #

Data DecidedStrictness 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness #

toConstr :: DecidedStrictness -> Constr #

dataTypeOf :: DecidedStrictness -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) #

gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r #

gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness #

Data Con 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Con -> c Con #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Con #

toConstr :: Con -> Constr #

dataTypeOf :: Con -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Con) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con) #

gmapT :: (forall b. Data b => b -> b) -> Con -> Con #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r #

gmapQ :: (forall d. Data d => d -> u) -> Con -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Con -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Con -> m Con #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Con -> m Con #

Data Bang 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bang -> c Bang #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bang #

toConstr :: Bang -> Constr #

dataTypeOf :: Bang -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bang) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bang) #

gmapT :: (forall b. Data b => b -> b) -> Bang -> Bang #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bang -> r #

gmapQ :: (forall d. Data d => d -> u) -> Bang -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bang -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bang -> m Bang #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bang -> m Bang #

Data PatSynDir 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynDir -> c PatSynDir #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynDir #

toConstr :: PatSynDir -> Constr #

dataTypeOf :: PatSynDir -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PatSynDir) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynDir) #

gmapT :: (forall b. Data b => b -> b) -> PatSynDir -> PatSynDir #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynDir -> r #

gmapQ :: (forall d. Data d => d -> u) -> PatSynDir -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynDir -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynDir -> m PatSynDir #

Data PatSynArgs 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatSynArgs -> c PatSynArgs #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PatSynArgs #

toConstr :: PatSynArgs -> Constr #

dataTypeOf :: PatSynArgs -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PatSynArgs) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PatSynArgs) #

gmapT :: (forall b. Data b => b -> b) -> PatSynArgs -> PatSynArgs #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatSynArgs -> r #

gmapQ :: (forall d. Data d => d -> u) -> PatSynArgs -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatSynArgs -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatSynArgs -> m PatSynArgs #

Data FamilyResultSig 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FamilyResultSig -> c FamilyResultSig #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FamilyResultSig #

toConstr :: FamilyResultSig -> Constr #

dataTypeOf :: FamilyResultSig -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FamilyResultSig) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FamilyResultSig) #

gmapT :: (forall b. Data b => b -> b) -> FamilyResultSig -> FamilyResultSig #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FamilyResultSig -> r #

gmapQ :: (forall d. Data d => d -> u) -> FamilyResultSig -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FamilyResultSig -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FamilyResultSig -> m FamilyResultSig #

Data TyLit 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyLit -> c TyLit #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyLit #

toConstr :: TyLit -> Constr #

dataTypeOf :: TyLit -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyLit) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyLit) #

gmapT :: (forall b. Data b => b -> b) -> TyLit -> TyLit #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyLit -> r #

gmapQ :: (forall d. Data d => d -> u) -> TyLit -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyLit -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyLit -> m TyLit #

Data Role 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role #

toConstr :: Role -> Constr #

dataTypeOf :: Role -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) #

gmapT :: (forall b. Data b => b -> b) -> Role -> Role #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r #

gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role #

Data AnnLookup 
Instance details

Defined in Language.Haskell.TH.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AnnLookup -> c AnnLookup #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AnnLookup #

toConstr :: AnnLookup -> Constr #

dataTypeOf :: AnnLookup -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c AnnLookup) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AnnLookup) #

gmapT :: (forall b. Data b => b -> b) -> AnnLookup -> AnnLookup #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AnnLookup -> r #

gmapQ :: (forall d. Data d => d -> u) -> AnnLookup -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> AnnLookup -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AnnLookup -> m AnnLookup #

Data DatatypeInfo 
Instance details

Defined in Language.Haskell.TH.Datatype

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DatatypeInfo -> c DatatypeInfo #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DatatypeInfo #

toConstr :: DatatypeInfo -> Constr #

dataTypeOf :: DatatypeInfo -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DatatypeInfo) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DatatypeInfo) #

gmapT :: (forall b. Data b => b -> b) -> DatatypeInfo -> DatatypeInfo #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DatatypeInfo -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DatatypeInfo -> r #

gmapQ :: (forall d. Data d => d -> u) -> DatatypeInfo -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DatatypeInfo -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DatatypeInfo -> m DatatypeInfo #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DatatypeInfo -> m DatatypeInfo #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DatatypeInfo -> m DatatypeInfo #

Data DatatypeVariant 
Instance details

Defined in Language.Haskell.TH.Datatype

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DatatypeVariant -> c DatatypeVariant #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DatatypeVariant #

toConstr :: DatatypeVariant -> Constr #

dataTypeOf :: DatatypeVariant -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DatatypeVariant) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DatatypeVariant) #

gmapT :: (forall b. Data b => b -> b) -> DatatypeVariant -> DatatypeVariant #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DatatypeVariant -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DatatypeVariant -> r #

gmapQ :: (forall d. Data d => d -> u) -> DatatypeVariant -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DatatypeVariant -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DatatypeVariant -> m DatatypeVariant #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DatatypeVariant -> m DatatypeVariant #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DatatypeVariant -> m DatatypeVariant #

Data ConstructorInfo 
Instance details

Defined in Language.Haskell.TH.Datatype

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstructorInfo -> c ConstructorInfo #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConstructorInfo #

toConstr :: ConstructorInfo -> Constr #

dataTypeOf :: ConstructorInfo -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ConstructorInfo) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstructorInfo) #

gmapT :: (forall b. Data b => b -> b) -> ConstructorInfo -> ConstructorInfo #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstructorInfo -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstructorInfo -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConstructorInfo -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstructorInfo -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstructorInfo -> m ConstructorInfo #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstructorInfo -> m ConstructorInfo #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstructorInfo -> m ConstructorInfo #

Data ConstructorVariant 
Instance details

Defined in Language.Haskell.TH.Datatype

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConstructorVariant -> c ConstructorVariant #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConstructorVariant #

toConstr :: ConstructorVariant -> Constr #

dataTypeOf :: ConstructorVariant -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ConstructorVariant) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConstructorVariant) #

gmapT :: (forall b. Data b => b -> b) -> ConstructorVariant -> ConstructorVariant #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConstructorVariant -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConstructorVariant -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConstructorVariant -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConstructorVariant -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConstructorVariant -> m ConstructorVariant #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstructorVariant -> m ConstructorVariant #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConstructorVariant -> m ConstructorVariant #

Data FieldStrictness 
Instance details

Defined in Language.Haskell.TH.Datatype

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldStrictness -> c FieldStrictness #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FieldStrictness #

toConstr :: FieldStrictness -> Constr #

dataTypeOf :: FieldStrictness -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FieldStrictness) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FieldStrictness) #

gmapT :: (forall b. Data b => b -> b) -> FieldStrictness -> FieldStrictness #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldStrictness -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldStrictness -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldStrictness -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldStrictness -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldStrictness -> m FieldStrictness #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldStrictness -> m FieldStrictness #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldStrictness -> m FieldStrictness #

Data Unpackedness 
Instance details

Defined in Language.Haskell.TH.Datatype

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Unpackedness -> c Unpackedness #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Unpackedness #

toConstr :: Unpackedness -> Constr #

dataTypeOf :: Unpackedness -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Unpackedness) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Unpackedness) #

gmapT :: (forall b. Data b => b -> b) -> Unpackedness -> Unpackedness #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unpackedness -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unpackedness -> r #

gmapQ :: (forall d. Data d => d -> u) -> Unpackedness -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Unpackedness -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unpackedness -> m Unpackedness #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unpackedness -> m Unpackedness #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unpackedness -> m Unpackedness #

Data Strictness 
Instance details

Defined in Language.Haskell.TH.Datatype

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Strictness -> c Strictness #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Strictness #

toConstr :: Strictness -> Constr #

dataTypeOf :: Strictness -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Strictness) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Strictness) #

gmapT :: (forall b. Data b => b -> b) -> Strictness -> Strictness #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Strictness -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Strictness -> r #

gmapQ :: (forall d. Data d => d -> u) -> Strictness -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Strictness -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Strictness -> m Strictness #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Strictness -> m Strictness #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Strictness -> m Strictness #

Data Specificity 
Instance details

Defined in Language.Haskell.TH.Datatype.TyVarBndr

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Specificity -> c Specificity #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Specificity #

toConstr :: Specificity -> Constr #

dataTypeOf :: Specificity -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Specificity) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Specificity) #

gmapT :: (forall b. Data b => b -> b) -> Specificity -> Specificity #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Specificity -> r #

gmapQ :: (forall d. Data d => d -> u) -> Specificity -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Specificity -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Specificity -> m Specificity #

Data ZonedTime 
Instance details

Defined in Data.Time.LocalTime.Internal.ZonedTime

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZonedTime -> c ZonedTime #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ZonedTime #

toConstr :: ZonedTime -> Constr #

dataTypeOf :: ZonedTime -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ZonedTime) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ZonedTime) #

gmapT :: (forall b. Data b => b -> b) -> ZonedTime -> ZonedTime #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZonedTime -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZonedTime -> r #

gmapQ :: (forall d. Data d => d -> u) -> ZonedTime -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ZonedTime -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZonedTime -> m ZonedTime #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZonedTime -> m ZonedTime #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZonedTime -> m ZonedTime #

Data LocalTime 
Instance details

Defined in Data.Time.LocalTime.Internal.LocalTime

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LocalTime -> c LocalTime #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LocalTime #

toConstr :: LocalTime -> Constr #

dataTypeOf :: LocalTime -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c LocalTime) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LocalTime) #

gmapT :: (forall b. Data b => b -> b) -> LocalTime -> LocalTime #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LocalTime -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LocalTime -> r #

gmapQ :: (forall d. Data d => d -> u) -> LocalTime -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LocalTime -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LocalTime -> m LocalTime #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LocalTime -> m LocalTime #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LocalTime -> m LocalTime #

Data a => Data [a]

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> [a] -> c [a] #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c [a] #

toConstr :: [a] -> Constr #

dataTypeOf :: [a] -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c [a]) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c [a]) #

gmapT :: (forall b. Data b => b -> b) -> [a] -> [a] #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r #

gmapQ :: (forall d. Data d => d -> u) -> [a] -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> [a] -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> [a] -> m [a] #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] #

Data a => Data (Maybe a)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) #

toConstr :: Maybe a -> Constr #

dataTypeOf :: Maybe a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) #

gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) #

(Data a, Integral a) => Data (Ratio a)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ratio a -> c (Ratio a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ratio a) #

toConstr :: Ratio a -> Constr #

dataTypeOf :: Ratio a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ratio a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ratio a)) #

gmapT :: (forall b. Data b => b -> b) -> Ratio a -> Ratio a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ratio a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ratio a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) #

Data a => Data (Ptr a)

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) #

toConstr :: Ptr a -> Constr #

dataTypeOf :: Ptr a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) #

gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) #

Data p => Data (Par1 p)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Par1 p -> c (Par1 p) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Par1 p) #

toConstr :: Par1 p -> Constr #

dataTypeOf :: Par1 p -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Par1 p)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Par1 p)) #

gmapT :: (forall b. Data b => b -> b) -> Par1 p -> Par1 p #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r #

gmapQ :: (forall d. Data d => d -> u) -> Par1 p -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Par1 p -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) #

(Data a, Ord a) => Data (Set a) 
Instance details

Defined in Data.Set.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Set a -> c (Set a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Set a) #

toConstr :: Set a -> Constr #

dataTypeOf :: Set a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Set a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Set a)) #

gmapT :: (forall b. Data b => b -> b) -> Set a -> Set a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Set a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Set a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #

Data a => Data (ForeignPtr a)

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignPtr a -> c (ForeignPtr a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignPtr a) #

toConstr :: ForeignPtr a -> Constr #

dataTypeOf :: ForeignPtr a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignPtr a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignPtr a)) #

gmapT :: (forall b. Data b => b -> b) -> ForeignPtr a -> ForeignPtr a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ForeignPtr a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignPtr a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) #

Data a => Data (Complex a)

Since: base-2.1

Instance details

Defined in Data.Complex

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) #

toConstr :: Complex a -> Constr #

dataTypeOf :: Complex a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) #

gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

Data a => Data (Min a)

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Min a -> c (Min a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Min a) #

toConstr :: Min a -> Constr #

dataTypeOf :: Min a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Min a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a)) #

gmapT :: (forall b. Data b => b -> b) -> Min a -> Min a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Min a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Min a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) #

Data a => Data (Max a)

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Max a -> c (Max a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Max a) #

toConstr :: Max a -> Constr #

dataTypeOf :: Max a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Max a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a)) #

gmapT :: (forall b. Data b => b -> b) -> Max a -> Max a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Max a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Max a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) #

Data a => Data (First a)

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) #

toConstr :: First a -> Constr #

dataTypeOf :: First a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) #

gmapT :: (forall b. Data b => b -> b) -> First a -> First a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r #

gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) #

Data a => Data (Last a)

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) #

toConstr :: Last a -> Constr #

dataTypeOf :: Last a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) #

gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) #

Data m => Data (WrappedMonoid m)

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m) #

toConstr :: WrappedMonoid m -> Constr #

dataTypeOf :: WrappedMonoid m -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonoid m)) #

gmapT :: (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r #

gmapQ :: (forall d. Data d => d -> u) -> WrappedMonoid m -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u #

gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) #

gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) #

gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonoid m -> m0 (WrappedMonoid m) #

Data a => Data (Option a)

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Option a -> c (Option a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Option a) #

toConstr :: Option a -> Constr #

dataTypeOf :: Option a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Option a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Option a)) #

gmapT :: (forall b. Data b => b -> b) -> Option a -> Option a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Option a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Option a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) #

Data a => Data (ZipList a)

Since: base-4.14.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ZipList a -> c (ZipList a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ZipList a) #

toConstr :: ZipList a -> Constr #

dataTypeOf :: ZipList a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ZipList a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ZipList a)) #

gmapT :: (forall b. Data b => b -> b) -> ZipList a -> ZipList a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZipList a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ZipList a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ZipList a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ZipList a -> m (ZipList a) #

Data a => Data (Identity a)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Identity a -> c (Identity a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Identity a) #

toConstr :: Identity a -> Constr #

dataTypeOf :: Identity a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Identity a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Identity a)) #

gmapT :: (forall b. Data b => b -> b) -> Identity a -> Identity a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Identity a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Identity a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) #

Data a => Data (First a)

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) #

toConstr :: First a -> Constr #

dataTypeOf :: First a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) #

gmapT :: (forall b. Data b => b -> b) -> First a -> First a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r #

gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) #

Data a => Data (Last a)

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) #

toConstr :: Last a -> Constr #

dataTypeOf :: Last a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) #

gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) #

Data a => Data (Dual a)

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dual a -> c (Dual a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dual a) #

toConstr :: Dual a -> Constr #

dataTypeOf :: Dual a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dual a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dual a)) #

gmapT :: (forall b. Data b => b -> b) -> Dual a -> Dual a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Dual a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dual a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) #

Data a => Data (Sum a)

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sum a -> c (Sum a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum a) #

toConstr :: Sum a -> Constr #

dataTypeOf :: Sum a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a)) #

gmapT :: (forall b. Data b => b -> b) -> Sum a -> Sum a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Sum a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) #

Data a => Data (Product a)

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Product a -> c (Product a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product a) #

toConstr :: Product a -> Constr #

dataTypeOf :: Product a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Product a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product a)) #

gmapT :: (forall b. Data b => b -> b) -> Product a -> Product a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Product a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Product a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) #

Data a => Data (Down a)

Since: base-4.12.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Down a -> c (Down a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Down a) #

toConstr :: Down a -> Constr #

dataTypeOf :: Down a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Down a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Down a)) #

gmapT :: (forall b. Data b => b -> b) -> Down a -> Down a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Down a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Down a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Down a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Down a -> m (Down a) #

Data a => Data (NonEmpty a)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmpty a) #

toConstr :: NonEmpty a -> Constr #

dataTypeOf :: NonEmpty a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmpty a)) #

gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r #

gmapQ :: (forall d. Data d => d -> u) -> NonEmpty a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) #

Data a => Data (IntMap a) 
Instance details

Defined in Data.IntMap.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntMap a -> c (IntMap a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IntMap a) #

toConstr :: IntMap a -> Constr #

dataTypeOf :: IntMap a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (IntMap a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IntMap a)) #

gmapT :: (forall b. Data b => b -> b) -> IntMap a -> IntMap a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r #

gmapQ :: (forall d. Data d => d -> u) -> IntMap a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IntMap a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a) #

Data a => Data (Tree a) 
Instance details

Defined in Data.Tree

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tree a -> c (Tree a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Tree a) #

toConstr :: Tree a -> Constr #

dataTypeOf :: Tree a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Tree a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tree a)) #

gmapT :: (forall b. Data b => b -> b) -> Tree a -> Tree a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tree a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tree a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Tree a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tree a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tree a -> m (Tree a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tree a -> m (Tree a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tree a -> m (Tree a) #

Data a => Data (Seq a) 
Instance details

Defined in Data.Sequence.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Seq a -> c (Seq a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Seq a) #

toConstr :: Seq a -> Constr #

dataTypeOf :: Seq a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Seq a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Seq a)) #

gmapT :: (forall b. Data b => b -> b) -> Seq a -> Seq a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Seq a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Seq a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) #

Data a => Data (ViewL a) 
Instance details

Defined in Data.Sequence.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ViewL a -> c (ViewL a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ViewL a) #

toConstr :: ViewL a -> Constr #

dataTypeOf :: ViewL a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ViewL a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ViewL a)) #

gmapT :: (forall b. Data b => b -> b) -> ViewL a -> ViewL a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ViewL a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ViewL a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ViewL a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ViewL a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ViewL a -> m (ViewL a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewL a -> m (ViewL a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewL a -> m (ViewL a) #

Data a => Data (ViewR a) 
Instance details

Defined in Data.Sequence.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ViewR a -> c (ViewR a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ViewR a) #

toConstr :: ViewR a -> Constr #

dataTypeOf :: ViewR a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ViewR a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ViewR a)) #

gmapT :: (forall b. Data b => b -> b) -> ViewR a -> ViewR a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ViewR a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ViewR a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ViewR a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ViewR a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ViewR a -> m (ViewR a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewR a -> m (ViewR a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewR a -> m (ViewR a) #

Data a => Data (Errors a) 
Instance details

Defined in Happstack.Server.RqData

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Errors a -> c (Errors a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Errors a) #

toConstr :: Errors a -> Constr #

dataTypeOf :: Errors a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Errors a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Errors a)) #

gmapT :: (forall b. Data b => b -> b) -> Errors a -> Errors a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Errors a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Errors a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Errors a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Errors a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Errors a -> m (Errors a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Errors a -> m (Errors a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Errors a -> m (Errors a) #

Data l => Data (PragmasAndModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PragmasAndModuleName l -> c (PragmasAndModuleName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PragmasAndModuleName l) #

toConstr :: PragmasAndModuleName l -> Constr #

dataTypeOf :: PragmasAndModuleName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PragmasAndModuleName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PragmasAndModuleName l)) #

gmapT :: (forall b. Data b => b -> b) -> PragmasAndModuleName l -> PragmasAndModuleName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PragmasAndModuleName l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PragmasAndModuleName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> PragmasAndModuleName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PragmasAndModuleName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PragmasAndModuleName l -> m (PragmasAndModuleName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PragmasAndModuleName l -> m (PragmasAndModuleName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PragmasAndModuleName l -> m (PragmasAndModuleName l) #

Data l => Data (PragmasAndModuleHead l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PragmasAndModuleHead l -> c (PragmasAndModuleHead l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PragmasAndModuleHead l) #

toConstr :: PragmasAndModuleHead l -> Constr #

dataTypeOf :: PragmasAndModuleHead l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PragmasAndModuleHead l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PragmasAndModuleHead l)) #

gmapT :: (forall b. Data b => b -> b) -> PragmasAndModuleHead l -> PragmasAndModuleHead l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PragmasAndModuleHead l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PragmasAndModuleHead l -> r #

gmapQ :: (forall d. Data d => d -> u) -> PragmasAndModuleHead l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PragmasAndModuleHead l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PragmasAndModuleHead l -> m (PragmasAndModuleHead l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PragmasAndModuleHead l -> m (PragmasAndModuleHead l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PragmasAndModuleHead l -> m (PragmasAndModuleHead l) #

Data l => Data (ModuleHeadAndImports l) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleHeadAndImports l -> c (ModuleHeadAndImports l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModuleHeadAndImports l) #

toConstr :: ModuleHeadAndImports l -> Constr #

dataTypeOf :: ModuleHeadAndImports l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ModuleHeadAndImports l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModuleHeadAndImports l)) #

gmapT :: (forall b. Data b => b -> b) -> ModuleHeadAndImports l -> ModuleHeadAndImports l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHeadAndImports l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHeadAndImports l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModuleHeadAndImports l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleHeadAndImports l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleHeadAndImports l -> m (ModuleHeadAndImports l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHeadAndImports l -> m (ModuleHeadAndImports l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHeadAndImports l -> m (ModuleHeadAndImports l) #

Data a => Data (NonGreedy a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonGreedy a -> c (NonGreedy a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonGreedy a) #

toConstr :: NonGreedy a -> Constr #

dataTypeOf :: NonGreedy a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (NonGreedy a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonGreedy a)) #

gmapT :: (forall b. Data b => b -> b) -> NonGreedy a -> NonGreedy a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonGreedy a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonGreedy a -> r #

gmapQ :: (forall d. Data d => d -> u) -> NonGreedy a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NonGreedy a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonGreedy a -> m (NonGreedy a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonGreedy a -> m (NonGreedy a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonGreedy a -> m (NonGreedy a) #

Data a => Data (ListOf a) 
Instance details

Defined in Language.Haskell.Exts.Parser

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ListOf a -> c (ListOf a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ListOf a) #

toConstr :: ListOf a -> Constr #

dataTypeOf :: ListOf a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ListOf a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ListOf a)) #

gmapT :: (forall b. Data b => b -> b) -> ListOf a -> ListOf a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ListOf a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ListOf a -> r #

gmapQ :: (forall d. Data d => d -> u) -> ListOf a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ListOf a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ListOf a -> m (ListOf a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ListOf a -> m (ListOf a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ListOf a -> m (ListOf a) #

Data l => Data (ModuleName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleName l -> c (ModuleName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModuleName l) #

toConstr :: ModuleName l -> Constr #

dataTypeOf :: ModuleName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ModuleName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModuleName l)) #

gmapT :: (forall b. Data b => b -> b) -> ModuleName l -> ModuleName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModuleName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleName l -> m (ModuleName l) #

Data l => Data (SpecialCon l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpecialCon l -> c (SpecialCon l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SpecialCon l) #

toConstr :: SpecialCon l -> Constr #

dataTypeOf :: SpecialCon l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SpecialCon l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SpecialCon l)) #

gmapT :: (forall b. Data b => b -> b) -> SpecialCon l -> SpecialCon l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpecialCon l -> r #

gmapQ :: (forall d. Data d => d -> u) -> SpecialCon l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SpecialCon l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecialCon l -> m (SpecialCon l) #

Data l => Data (QName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QName l -> c (QName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QName l) #

toConstr :: QName l -> Constr #

dataTypeOf :: QName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QName l)) #

gmapT :: (forall b. Data b => b -> b) -> QName l -> QName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QName l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> QName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QName l -> m (QName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QName l -> m (QName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QName l -> m (QName l) #

Data l => Data (Name l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name l -> c (Name l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Name l) #

toConstr :: Name l -> Constr #

dataTypeOf :: Name l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Name l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Name l)) #

gmapT :: (forall b. Data b => b -> b) -> Name l -> Name l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Name l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Name l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name l -> m (Name l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name l -> m (Name l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name l -> m (Name l) #

Data l => Data (IPName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPName l -> c (IPName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IPName l) #

toConstr :: IPName l -> Constr #

dataTypeOf :: IPName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (IPName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPName l)) #

gmapT :: (forall b. Data b => b -> b) -> IPName l -> IPName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPName l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> IPName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IPName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPName l -> m (IPName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPName l -> m (IPName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPName l -> m (IPName l) #

Data l => Data (QOp l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QOp l -> c (QOp l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QOp l) #

toConstr :: QOp l -> Constr #

dataTypeOf :: QOp l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QOp l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QOp l)) #

gmapT :: (forall b. Data b => b -> b) -> QOp l -> QOp l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QOp l -> r #

gmapQ :: (forall d. Data d => d -> u) -> QOp l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QOp l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QOp l -> m (QOp l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QOp l -> m (QOp l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QOp l -> m (QOp l) #

Data l => Data (Op l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Op l -> c (Op l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Op l) #

toConstr :: Op l -> Constr #

dataTypeOf :: Op l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Op l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Op l)) #

gmapT :: (forall b. Data b => b -> b) -> Op l -> Op l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Op l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Op l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Op l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Op l -> m (Op l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Op l -> m (Op l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Op l -> m (Op l) #

Data l => Data (CName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CName l -> c (CName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CName l) #

toConstr :: CName l -> Constr #

dataTypeOf :: CName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (CName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CName l)) #

gmapT :: (forall b. Data b => b -> b) -> CName l -> CName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CName l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> CName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CName l -> m (CName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CName l -> m (CName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CName l -> m (CName l) #

Data l => Data (Module l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module l -> c (Module l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Module l) #

toConstr :: Module l -> Constr #

dataTypeOf :: Module l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Module l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Module l)) #

gmapT :: (forall b. Data b => b -> b) -> Module l -> Module l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Module l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module l -> m (Module l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module l -> m (Module l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module l -> m (Module l) #

Data l => Data (ModuleHead l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleHead l -> c (ModuleHead l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModuleHead l) #

toConstr :: ModuleHead l -> Constr #

dataTypeOf :: ModuleHead l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ModuleHead l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModuleHead l)) #

gmapT :: (forall b. Data b => b -> b) -> ModuleHead l -> ModuleHead l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleHead l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModuleHead l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleHead l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleHead l -> m (ModuleHead l) #

Data l => Data (ExportSpecList l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExportSpecList l -> c (ExportSpecList l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExportSpecList l) #

toConstr :: ExportSpecList l -> Constr #

dataTypeOf :: ExportSpecList l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ExportSpecList l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExportSpecList l)) #

gmapT :: (forall b. Data b => b -> b) -> ExportSpecList l -> ExportSpecList l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpecList l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ExportSpecList l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExportSpecList l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExportSpecList l -> m (ExportSpecList l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpecList l -> m (ExportSpecList l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpecList l -> m (ExportSpecList l) #

Data l => Data (ExportSpec l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExportSpec l -> c (ExportSpec l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ExportSpec l) #

toConstr :: ExportSpec l -> Constr #

dataTypeOf :: ExportSpec l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ExportSpec l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ExportSpec l)) #

gmapT :: (forall b. Data b => b -> b) -> ExportSpec l -> ExportSpec l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExportSpec l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ExportSpec l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExportSpec l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExportSpec l -> m (ExportSpec l) #

Data l => Data (EWildcard l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> EWildcard l -> c (EWildcard l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (EWildcard l) #

toConstr :: EWildcard l -> Constr #

dataTypeOf :: EWildcard l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (EWildcard l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (EWildcard l)) #

gmapT :: (forall b. Data b => b -> b) -> EWildcard l -> EWildcard l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> EWildcard l -> r #

gmapQ :: (forall d. Data d => d -> u) -> EWildcard l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> EWildcard l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> EWildcard l -> m (EWildcard l) #

Data l => Data (Namespace l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Namespace l -> c (Namespace l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Namespace l) #

toConstr :: Namespace l -> Constr #

dataTypeOf :: Namespace l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Namespace l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Namespace l)) #

gmapT :: (forall b. Data b => b -> b) -> Namespace l -> Namespace l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Namespace l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Namespace l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Namespace l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Namespace l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Namespace l -> m (Namespace l) #

Data l => Data (ImportDecl l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportDecl l) #

toConstr :: ImportDecl l -> Constr #

dataTypeOf :: ImportDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l) #

Data l => Data (ImportSpecList l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSpecList l -> c (ImportSpecList l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportSpecList l) #

toConstr :: ImportSpecList l -> Constr #

dataTypeOf :: ImportSpecList l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportSpecList l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportSpecList l)) #

gmapT :: (forall b. Data b => b -> b) -> ImportSpecList l -> ImportSpecList l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpecList l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportSpecList l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpecList l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpecList l -> m (ImportSpecList l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpecList l -> m (ImportSpecList l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpecList l -> m (ImportSpecList l) #

Data l => Data (ImportSpec l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSpec l -> c (ImportSpec l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportSpec l) #

toConstr :: ImportSpec l -> Constr #

dataTypeOf :: ImportSpec l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportSpec l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportSpec l)) #

gmapT :: (forall b. Data b => b -> b) -> ImportSpec l -> ImportSpec l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ImportSpec l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpec l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec l -> m (ImportSpec l) #

Data l => Data (Assoc l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Assoc l -> c (Assoc l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Assoc l) #

toConstr :: Assoc l -> Constr #

dataTypeOf :: Assoc l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Assoc l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Assoc l)) #

gmapT :: (forall b. Data b => b -> b) -> Assoc l -> Assoc l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Assoc l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Assoc l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Assoc l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Assoc l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Assoc l -> m (Assoc l) #

Data l => Data (Decl l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Decl l -> c (Decl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Decl l) #

toConstr :: Decl l -> Constr #

dataTypeOf :: Decl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Decl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Decl l)) #

gmapT :: (forall b. Data b => b -> b) -> Decl l -> Decl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Decl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Decl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Decl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Decl l -> m (Decl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl l -> m (Decl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Decl l -> m (Decl l) #

Data l => Data (PatternSynDirection l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatternSynDirection l -> c (PatternSynDirection l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PatternSynDirection l) #

toConstr :: PatternSynDirection l -> Constr #

dataTypeOf :: PatternSynDirection l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PatternSynDirection l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PatternSynDirection l)) #

gmapT :: (forall b. Data b => b -> b) -> PatternSynDirection l -> PatternSynDirection l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatternSynDirection l -> r #

gmapQ :: (forall d. Data d => d -> u) -> PatternSynDirection l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatternSynDirection l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatternSynDirection l -> m (PatternSynDirection l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatternSynDirection l -> m (PatternSynDirection l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatternSynDirection l -> m (PatternSynDirection l) #

Data l => Data (TypeEqn l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeEqn l -> c (TypeEqn l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TypeEqn l) #

toConstr :: TypeEqn l -> Constr #

dataTypeOf :: TypeEqn l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TypeEqn l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TypeEqn l)) #

gmapT :: (forall b. Data b => b -> b) -> TypeEqn l -> TypeEqn l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeEqn l -> r #

gmapQ :: (forall d. Data d => d -> u) -> TypeEqn l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeEqn l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeEqn l -> m (TypeEqn l) #

Data l => Data (Annotation l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Annotation l -> c (Annotation l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Annotation l) #

toConstr :: Annotation l -> Constr #

dataTypeOf :: Annotation l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Annotation l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Annotation l)) #

gmapT :: (forall b. Data b => b -> b) -> Annotation l -> Annotation l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Annotation l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Annotation l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Annotation l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Annotation l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Annotation l -> m (Annotation l) #

Data l => Data (BooleanFormula l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BooleanFormula l -> c (BooleanFormula l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BooleanFormula l) #

toConstr :: BooleanFormula l -> Constr #

dataTypeOf :: BooleanFormula l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BooleanFormula l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BooleanFormula l)) #

gmapT :: (forall b. Data b => b -> b) -> BooleanFormula l -> BooleanFormula l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BooleanFormula l -> r #

gmapQ :: (forall d. Data d => d -> u) -> BooleanFormula l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BooleanFormula l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BooleanFormula l -> m (BooleanFormula l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BooleanFormula l -> m (BooleanFormula l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BooleanFormula l -> m (BooleanFormula l) #

Data l => Data (Role l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role l -> c (Role l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Role l) #

toConstr :: Role l -> Constr #

dataTypeOf :: Role l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Role l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Role l)) #

gmapT :: (forall b. Data b => b -> b) -> Role l -> Role l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Role l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Role l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role l -> m (Role l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role l -> m (Role l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role l -> m (Role l) #

Data l => Data (DataOrNew l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DataOrNew l -> c (DataOrNew l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DataOrNew l) #

toConstr :: DataOrNew l -> Constr #

dataTypeOf :: DataOrNew l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DataOrNew l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DataOrNew l)) #

gmapT :: (forall b. Data b => b -> b) -> DataOrNew l -> DataOrNew l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DataOrNew l -> r #

gmapQ :: (forall d. Data d => d -> u) -> DataOrNew l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DataOrNew l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DataOrNew l -> m (DataOrNew l) #

Data l => Data (InjectivityInfo l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityInfo l -> c (InjectivityInfo l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InjectivityInfo l) #

toConstr :: InjectivityInfo l -> Constr #

dataTypeOf :: InjectivityInfo l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InjectivityInfo l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InjectivityInfo l)) #

gmapT :: (forall b. Data b => b -> b) -> InjectivityInfo l -> InjectivityInfo l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityInfo l -> r #

gmapQ :: (forall d. Data d => d -> u) -> InjectivityInfo l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityInfo l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityInfo l -> m (InjectivityInfo l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityInfo l -> m (InjectivityInfo l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityInfo l -> m (InjectivityInfo l) #

Data l => Data (ResultSig l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ResultSig l -> c (ResultSig l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ResultSig l) #

toConstr :: ResultSig l -> Constr #

dataTypeOf :: ResultSig l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ResultSig l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ResultSig l)) #

gmapT :: (forall b. Data b => b -> b) -> ResultSig l -> ResultSig l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ResultSig l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ResultSig l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ResultSig l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ResultSig l -> m (ResultSig l) #

Data l => Data (DeclHead l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DeclHead l -> c (DeclHead l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DeclHead l) #

toConstr :: DeclHead l -> Constr #

dataTypeOf :: DeclHead l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DeclHead l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DeclHead l)) #

gmapT :: (forall b. Data b => b -> b) -> DeclHead l -> DeclHead l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DeclHead l -> r #

gmapQ :: (forall d. Data d => d -> u) -> DeclHead l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DeclHead l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DeclHead l -> m (DeclHead l) #

Data l => Data (InstRule l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstRule l -> c (InstRule l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstRule l) #

toConstr :: InstRule l -> Constr #

dataTypeOf :: InstRule l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstRule l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstRule l)) #

gmapT :: (forall b. Data b => b -> b) -> InstRule l -> InstRule l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstRule l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstRule l -> r #

gmapQ :: (forall d. Data d => d -> u) -> InstRule l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstRule l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstRule l -> m (InstRule l) #

Data l => Data (InstHead l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstHead l -> c (InstHead l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstHead l) #

toConstr :: InstHead l -> Constr #

dataTypeOf :: InstHead l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstHead l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstHead l)) #

gmapT :: (forall b. Data b => b -> b) -> InstHead l -> InstHead l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstHead l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstHead l -> r #

gmapQ :: (forall d. Data d => d -> u) -> InstHead l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstHead l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstHead l -> m (InstHead l) #

Data l => Data (Deriving l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Deriving l -> c (Deriving l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Deriving l) #

toConstr :: Deriving l -> Constr #

dataTypeOf :: Deriving l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Deriving l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Deriving l)) #

gmapT :: (forall b. Data b => b -> b) -> Deriving l -> Deriving l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Deriving l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Deriving l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Deriving l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Deriving l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Deriving l -> m (Deriving l) #

Data l => Data (DerivStrategy l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy l -> c (DerivStrategy l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (DerivStrategy l) #

toConstr :: DerivStrategy l -> Constr #

dataTypeOf :: DerivStrategy l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (DerivStrategy l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (DerivStrategy l)) #

gmapT :: (forall b. Data b => b -> b) -> DerivStrategy l -> DerivStrategy l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy l -> r #

gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy l -> m (DerivStrategy l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy l -> m (DerivStrategy l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy l -> m (DerivStrategy l) #

Data l => Data (Binds l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Binds l -> c (Binds l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Binds l) #

toConstr :: Binds l -> Constr #

dataTypeOf :: Binds l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Binds l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Binds l)) #

gmapT :: (forall b. Data b => b -> b) -> Binds l -> Binds l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Binds l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Binds l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Binds l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Binds l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Binds l -> m (Binds l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Binds l -> m (Binds l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Binds l -> m (Binds l) #

Data l => Data (IPBind l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IPBind l -> c (IPBind l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IPBind l) #

toConstr :: IPBind l -> Constr #

dataTypeOf :: IPBind l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (IPBind l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IPBind l)) #

gmapT :: (forall b. Data b => b -> b) -> IPBind l -> IPBind l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IPBind l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IPBind l -> r #

gmapQ :: (forall d. Data d => d -> u) -> IPBind l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IPBind l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IPBind l -> m (IPBind l) #

Data l => Data (Match l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match l -> c (Match l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Match l) #

toConstr :: Match l -> Constr #

dataTypeOf :: Match l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Match l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Match l)) #

gmapT :: (forall b. Data b => b -> b) -> Match l -> Match l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Match l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Match l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match l -> m (Match l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match l -> m (Match l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match l -> m (Match l) #

Data l => Data (QualConDecl l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QualConDecl l -> c (QualConDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QualConDecl l) #

toConstr :: QualConDecl l -> Constr #

dataTypeOf :: QualConDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QualConDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QualConDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> QualConDecl l -> QualConDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QualConDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> QualConDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QualConDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QualConDecl l -> m (QualConDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QualConDecl l -> m (QualConDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QualConDecl l -> m (QualConDecl l) #

Data l => Data (ConDecl l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConDecl l -> c (ConDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ConDecl l) #

toConstr :: ConDecl l -> Constr #

dataTypeOf :: ConDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ConDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ConDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> ConDecl l -> ConDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ConDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConDecl l -> m (ConDecl l) #

Data l => Data (FieldDecl l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldDecl l -> c (FieldDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldDecl l) #

toConstr :: FieldDecl l -> Constr #

dataTypeOf :: FieldDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> FieldDecl l -> FieldDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldDecl l -> m (FieldDecl l) #

Data l => Data (GadtDecl l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GadtDecl l -> c (GadtDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GadtDecl l) #

toConstr :: GadtDecl l -> Constr #

dataTypeOf :: GadtDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GadtDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GadtDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> GadtDecl l -> GadtDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GadtDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> GadtDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GadtDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GadtDecl l -> m (GadtDecl l) #

Data l => Data (ClassDecl l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ClassDecl l -> c (ClassDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ClassDecl l) #

toConstr :: ClassDecl l -> Constr #

dataTypeOf :: ClassDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ClassDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ClassDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> ClassDecl l -> ClassDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ClassDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ClassDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ClassDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ClassDecl l -> m (ClassDecl l) #

Data l => Data (InstDecl l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InstDecl l -> c (InstDecl l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (InstDecl l) #

toConstr :: InstDecl l -> Constr #

dataTypeOf :: InstDecl l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (InstDecl l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (InstDecl l)) #

gmapT :: (forall b. Data b => b -> b) -> InstDecl l -> InstDecl l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InstDecl l -> r #

gmapQ :: (forall d. Data d => d -> u) -> InstDecl l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> InstDecl l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InstDecl l -> m (InstDecl l) #

Data l => Data (BangType l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BangType l -> c (BangType l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (BangType l) #

toConstr :: BangType l -> Constr #

dataTypeOf :: BangType l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (BangType l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (BangType l)) #

gmapT :: (forall b. Data b => b -> b) -> BangType l -> BangType l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BangType l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BangType l -> r #

gmapQ :: (forall d. Data d => d -> u) -> BangType l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BangType l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BangType l -> m (BangType l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BangType l -> m (BangType l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BangType l -> m (BangType l) #

Data l => Data (Unpackedness l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Unpackedness l -> c (Unpackedness l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Unpackedness l) #

toConstr :: Unpackedness l -> Constr #

dataTypeOf :: Unpackedness l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Unpackedness l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Unpackedness l)) #

gmapT :: (forall b. Data b => b -> b) -> Unpackedness l -> Unpackedness l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Unpackedness l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Unpackedness l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Unpackedness l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Unpackedness l -> m (Unpackedness l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Unpackedness l -> m (Unpackedness l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Unpackedness l -> m (Unpackedness l) #

Data l => Data (Rhs l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rhs l -> c (Rhs l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rhs l) #

toConstr :: Rhs l -> Constr #

dataTypeOf :: Rhs l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rhs l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rhs l)) #

gmapT :: (forall b. Data b => b -> b) -> Rhs l -> Rhs l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rhs l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Rhs l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rhs l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rhs l -> m (Rhs l) #

Data l => Data (GuardedRhs l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GuardedRhs l -> c (GuardedRhs l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GuardedRhs l) #

toConstr :: GuardedRhs l -> Constr #

dataTypeOf :: GuardedRhs l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GuardedRhs l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GuardedRhs l)) #

gmapT :: (forall b. Data b => b -> b) -> GuardedRhs l -> GuardedRhs l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GuardedRhs l -> r #

gmapQ :: (forall d. Data d => d -> u) -> GuardedRhs l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GuardedRhs l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GuardedRhs l -> m (GuardedRhs l) #

Data l => Data (Type l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type l -> c (Type l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Type l) #

toConstr :: Type l -> Constr #

dataTypeOf :: Type l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Type l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Type l)) #

gmapT :: (forall b. Data b => b -> b) -> Type l -> Type l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Type l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Type l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type l -> m (Type l) #

Data l => Data (MaybePromotedName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MaybePromotedName l -> c (MaybePromotedName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MaybePromotedName l) #

toConstr :: MaybePromotedName l -> Constr #

dataTypeOf :: MaybePromotedName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MaybePromotedName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MaybePromotedName l)) #

gmapT :: (forall b. Data b => b -> b) -> MaybePromotedName l -> MaybePromotedName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MaybePromotedName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> MaybePromotedName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MaybePromotedName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MaybePromotedName l -> m (MaybePromotedName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MaybePromotedName l -> m (MaybePromotedName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MaybePromotedName l -> m (MaybePromotedName l) #

Data l => Data (Promoted l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Promoted l -> c (Promoted l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Promoted l) #

toConstr :: Promoted l -> Constr #

dataTypeOf :: Promoted l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Promoted l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Promoted l)) #

gmapT :: (forall b. Data b => b -> b) -> Promoted l -> Promoted l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Promoted l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Promoted l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Promoted l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Promoted l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Promoted l -> m (Promoted l) #

Data l => Data (TyVarBind l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyVarBind l -> c (TyVarBind l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyVarBind l) #

toConstr :: TyVarBind l -> Constr #

dataTypeOf :: TyVarBind l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyVarBind l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyVarBind l)) #

gmapT :: (forall b. Data b => b -> b) -> TyVarBind l -> TyVarBind l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBind l -> r #

gmapQ :: (forall d. Data d => d -> u) -> TyVarBind l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyVarBind l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyVarBind l -> m (TyVarBind l) #

Data l => Data (FunDep l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep l -> c (FunDep l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FunDep l) #

toConstr :: FunDep l -> Constr #

dataTypeOf :: FunDep l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FunDep l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FunDep l)) #

gmapT :: (forall b. Data b => b -> b) -> FunDep l -> FunDep l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep l -> r #

gmapQ :: (forall d. Data d => d -> u) -> FunDep l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep l -> m (FunDep l) #

Data l => Data (Context l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Context l -> c (Context l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Context l) #

toConstr :: Context l -> Constr #

dataTypeOf :: Context l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Context l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Context l)) #

gmapT :: (forall b. Data b => b -> b) -> Context l -> Context l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Context l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Context l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Context l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Context l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Context l -> m (Context l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Context l -> m (Context l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Context l -> m (Context l) #

Data l => Data (Asst l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Asst l -> c (Asst l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Asst l) #

toConstr :: Asst l -> Constr #

dataTypeOf :: Asst l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Asst l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Asst l)) #

gmapT :: (forall b. Data b => b -> b) -> Asst l -> Asst l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Asst l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Asst l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Asst l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Asst l -> m (Asst l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Asst l -> m (Asst l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Asst l -> m (Asst l) #

Data l => Data (Literal l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Literal l -> c (Literal l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Literal l) #

toConstr :: Literal l -> Constr #

dataTypeOf :: Literal l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Literal l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Literal l)) #

gmapT :: (forall b. Data b => b -> b) -> Literal l -> Literal l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Literal l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Literal l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Literal l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Literal l -> m (Literal l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal l -> m (Literal l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Literal l -> m (Literal l) #

Data l => Data (Sign l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sign l -> c (Sign l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sign l) #

toConstr :: Sign l -> Constr #

dataTypeOf :: Sign l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sign l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sign l)) #

gmapT :: (forall b. Data b => b -> b) -> Sign l -> Sign l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sign l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Sign l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sign l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sign l -> m (Sign l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign l -> m (Sign l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sign l -> m (Sign l) #

Data l => Data (Exp l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp l -> c (Exp l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Exp l) #

toConstr :: Exp l -> Constr #

dataTypeOf :: Exp l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Exp l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Exp l)) #

gmapT :: (forall b. Data b => b -> b) -> Exp l -> Exp l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Exp l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp l -> m (Exp l) #

Data l => Data (XName l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> XName l -> c (XName l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (XName l) #

toConstr :: XName l -> Constr #

dataTypeOf :: XName l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (XName l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XName l)) #

gmapT :: (forall b. Data b => b -> b) -> XName l -> XName l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> XName l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> XName l -> r #

gmapQ :: (forall d. Data d => d -> u) -> XName l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> XName l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> XName l -> m (XName l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> XName l -> m (XName l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> XName l -> m (XName l) #

Data l => Data (XAttr l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> XAttr l -> c (XAttr l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (XAttr l) #

toConstr :: XAttr l -> Constr #

dataTypeOf :: XAttr l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (XAttr l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (XAttr l)) #

gmapT :: (forall b. Data b => b -> b) -> XAttr l -> XAttr l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> XAttr l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> XAttr l -> r #

gmapQ :: (forall d. Data d => d -> u) -> XAttr l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> XAttr l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> XAttr l -> m (XAttr l) #

Data l => Data (Bracket l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bracket l -> c (Bracket l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Bracket l) #

toConstr :: Bracket l -> Constr #

dataTypeOf :: Bracket l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Bracket l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Bracket l)) #

gmapT :: (forall b. Data b => b -> b) -> Bracket l -> Bracket l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bracket l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bracket l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Bracket l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Bracket l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bracket l -> m (Bracket l) #

Data l => Data (Splice l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Splice l -> c (Splice l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Splice l) #

toConstr :: Splice l -> Constr #

dataTypeOf :: Splice l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Splice l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Splice l)) #

gmapT :: (forall b. Data b => b -> b) -> Splice l -> Splice l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Splice l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Splice l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Splice l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Splice l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Splice l -> m (Splice l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Splice l -> m (Splice l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Splice l -> m (Splice l) #

Data l => Data (Safety l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety l -> c (Safety l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Safety l) #

toConstr :: Safety l -> Constr #

dataTypeOf :: Safety l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Safety l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Safety l)) #

gmapT :: (forall b. Data b => b -> b) -> Safety l -> Safety l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Safety l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Safety l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Safety l -> m (Safety l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety l -> m (Safety l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Safety l -> m (Safety l) #

Data l => Data (CallConv l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CallConv l -> c (CallConv l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CallConv l) #

toConstr :: CallConv l -> Constr #

dataTypeOf :: CallConv l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (CallConv l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CallConv l)) #

gmapT :: (forall b. Data b => b -> b) -> CallConv l -> CallConv l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CallConv l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CallConv l -> r #

gmapQ :: (forall d. Data d => d -> u) -> CallConv l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CallConv l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CallConv l -> m (CallConv l) #

Data l => Data (ModulePragma l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModulePragma l -> c (ModulePragma l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ModulePragma l) #

toConstr :: ModulePragma l -> Constr #

dataTypeOf :: ModulePragma l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ModulePragma l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ModulePragma l)) #

gmapT :: (forall b. Data b => b -> b) -> ModulePragma l -> ModulePragma l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModulePragma l -> r #

gmapQ :: (forall d. Data d => d -> u) -> ModulePragma l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModulePragma l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModulePragma l -> m (ModulePragma l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma l -> m (ModulePragma l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModulePragma l -> m (ModulePragma l) #

Data l => Data (Overlap l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap l -> c (Overlap l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Overlap l) #

toConstr :: Overlap l -> Constr #

dataTypeOf :: Overlap l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Overlap l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Overlap l)) #

gmapT :: (forall b. Data b => b -> b) -> Overlap l -> Overlap l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Overlap l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap l -> m (Overlap l) #

Data l => Data (Activation l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Activation l -> c (Activation l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Activation l) #

toConstr :: Activation l -> Constr #

dataTypeOf :: Activation l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Activation l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Activation l)) #

gmapT :: (forall b. Data b => b -> b) -> Activation l -> Activation l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Activation l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Activation l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Activation l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Activation l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Activation l -> m (Activation l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Activation l -> m (Activation l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Activation l -> m (Activation l) #

Data l => Data (Rule l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rule l -> c (Rule l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rule l) #

toConstr :: Rule l -> Constr #

dataTypeOf :: Rule l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rule l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rule l)) #

gmapT :: (forall b. Data b => b -> b) -> Rule l -> Rule l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Rule l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rule l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rule l -> m (Rule l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rule l -> m (Rule l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rule l -> m (Rule l) #

Data l => Data (RuleVar l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RuleVar l -> c (RuleVar l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RuleVar l) #

toConstr :: RuleVar l -> Constr #

dataTypeOf :: RuleVar l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RuleVar l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RuleVar l)) #

gmapT :: (forall b. Data b => b -> b) -> RuleVar l -> RuleVar l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RuleVar l -> r #

gmapQ :: (forall d. Data d => d -> u) -> RuleVar l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RuleVar l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RuleVar l -> m (RuleVar l) #

Data l => Data (WarningText l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WarningText l -> c (WarningText l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WarningText l) #

toConstr :: WarningText l -> Constr #

dataTypeOf :: WarningText l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WarningText l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WarningText l)) #

gmapT :: (forall b. Data b => b -> b) -> WarningText l -> WarningText l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WarningText l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WarningText l -> r #

gmapQ :: (forall d. Data d => d -> u) -> WarningText l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WarningText l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WarningText l -> m (WarningText l) #

Data l => Data (Pat l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pat l -> c (Pat l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Pat l) #

toConstr :: Pat l -> Constr #

dataTypeOf :: Pat l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Pat l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Pat l)) #

gmapT :: (forall b. Data b => b -> b) -> Pat l -> Pat l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Pat l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat l -> m (Pat l) #

Data l => Data (PXAttr l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PXAttr l -> c (PXAttr l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PXAttr l) #

toConstr :: PXAttr l -> Constr #

dataTypeOf :: PXAttr l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PXAttr l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PXAttr l)) #

gmapT :: (forall b. Data b => b -> b) -> PXAttr l -> PXAttr l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PXAttr l -> r #

gmapQ :: (forall d. Data d => d -> u) -> PXAttr l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PXAttr l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PXAttr l -> m (PXAttr l) #

Data l => Data (RPatOp l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RPatOp l -> c (RPatOp l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RPatOp l) #

toConstr :: RPatOp l -> Constr #

dataTypeOf :: RPatOp l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RPatOp l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPatOp l)) #

gmapT :: (forall b. Data b => b -> b) -> RPatOp l -> RPatOp l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPatOp l -> r #

gmapQ :: (forall d. Data d => d -> u) -> RPatOp l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RPatOp l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RPatOp l -> m (RPatOp l) #

Data l => Data (RPat l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RPat l -> c (RPat l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (RPat l) #

toConstr :: RPat l -> Constr #

dataTypeOf :: RPat l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (RPat l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (RPat l)) #

gmapT :: (forall b. Data b => b -> b) -> RPat l -> RPat l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RPat l -> r #

gmapQ :: (forall d. Data d => d -> u) -> RPat l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> RPat l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RPat l -> m (RPat l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RPat l -> m (RPat l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RPat l -> m (RPat l) #

Data l => Data (PatField l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PatField l -> c (PatField l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (PatField l) #

toConstr :: PatField l -> Constr #

dataTypeOf :: PatField l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (PatField l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PatField l)) #

gmapT :: (forall b. Data b => b -> b) -> PatField l -> PatField l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PatField l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PatField l -> r #

gmapQ :: (forall d. Data d => d -> u) -> PatField l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PatField l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PatField l -> m (PatField l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PatField l -> m (PatField l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PatField l -> m (PatField l) #

Data l => Data (Stmt l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt l -> c (Stmt l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Stmt l) #

toConstr :: Stmt l -> Constr #

dataTypeOf :: Stmt l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Stmt l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Stmt l)) #

gmapT :: (forall b. Data b => b -> b) -> Stmt l -> Stmt l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Stmt l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt l -> m (Stmt l) #

Data l => Data (QualStmt l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> QualStmt l -> c (QualStmt l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (QualStmt l) #

toConstr :: QualStmt l -> Constr #

dataTypeOf :: QualStmt l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (QualStmt l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (QualStmt l)) #

gmapT :: (forall b. Data b => b -> b) -> QualStmt l -> QualStmt l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> QualStmt l -> r #

gmapQ :: (forall d. Data d => d -> u) -> QualStmt l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> QualStmt l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> QualStmt l -> m (QualStmt l) #

Data l => Data (FieldUpdate l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldUpdate l -> c (FieldUpdate l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldUpdate l) #

toConstr :: FieldUpdate l -> Constr #

dataTypeOf :: FieldUpdate l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (FieldUpdate l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldUpdate l)) #

gmapT :: (forall b. Data b => b -> b) -> FieldUpdate l -> FieldUpdate l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldUpdate l -> r #

gmapQ :: (forall d. Data d => d -> u) -> FieldUpdate l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldUpdate l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldUpdate l -> m (FieldUpdate l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldUpdate l -> m (FieldUpdate l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldUpdate l -> m (FieldUpdate l) #

Data l => Data (Alt l) 
Instance details

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt l -> c (Alt l) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt l) #

toConstr :: Alt l -> Constr #

dataTypeOf :: Alt l -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt l)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt l)) #

gmapT :: (forall b. Data b => b -> b) -> Alt l -> Alt l #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt l -> r #

gmapQ :: (forall d. Data d => d -> u) -> Alt l -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt l -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt l -> m (Alt l) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt l -> m (Alt l) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt l -> m (Alt l) #

Typeable s => Data (MutableByteArray s) 
Instance details

Defined in Data.Primitive.ByteArray

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MutableByteArray s -> c (MutableByteArray s) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MutableByteArray s) #

toConstr :: MutableByteArray s -> Constr #

dataTypeOf :: MutableByteArray s -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MutableByteArray s)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MutableByteArray s)) #

gmapT :: (forall b. Data b => b -> b) -> MutableByteArray s -> MutableByteArray s #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MutableByteArray s -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MutableByteArray s -> r #

gmapQ :: (forall d. Data d => d -> u) -> MutableByteArray s -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MutableByteArray s -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MutableByteArray s -> m (MutableByteArray s) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableByteArray s -> m (MutableByteArray s) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableByteArray s -> m (MutableByteArray s) #

Data a => Data (SmallArray a) 
Instance details

Defined in Data.Primitive.SmallArray

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SmallArray a -> c (SmallArray a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SmallArray a) #

toConstr :: SmallArray a -> Constr #

dataTypeOf :: SmallArray a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SmallArray a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SmallArray a)) #

gmapT :: (forall b. Data b => b -> b) -> SmallArray a -> SmallArray a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SmallArray a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SmallArray a -> r #

gmapQ :: (forall d. Data d => d -> u) -> SmallArray a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SmallArray a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SmallArray a -> m (SmallArray a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallArray a -> m (SmallArray a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallArray a -> m (SmallArray a) #

Data a => Data (Array a) 
Instance details

Defined in Data.Primitive.Array

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Array a -> c (Array a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array a) #

toConstr :: Array a -> Constr #

dataTypeOf :: Array a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a)) #

gmapT :: (forall b. Data b => b -> b) -> Array a -> Array a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Array a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Array a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array a -> m (Array a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a -> m (Array a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a -> m (Array a) #

(Data a, Unbox a) => Data (Vector a) 
Instance details

Defined in Data.Vector.Unboxed.Base

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) #

toConstr :: Vector a -> Constr #

dataTypeOf :: Vector a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) #

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

(Data a, Storable a) => Data (Vector a) 
Instance details

Defined in Data.Vector.Storable

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) #

toConstr :: Vector a -> Constr #

dataTypeOf :: Vector a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) #

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

(Data a, Prim a) => Data (Vector a) 
Instance details

Defined in Data.Vector.Primitive

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) #

toConstr :: Vector a -> Constr #

dataTypeOf :: Vector a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) #

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

Data a => Data (Vector a) 
Instance details

Defined in Data.Vector

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) #

toConstr :: Vector a -> Constr #

dataTypeOf :: Vector a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) #

gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #

(Data a, Data b) => Data (Either a b)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) #

toConstr :: Either a b -> Constr #

dataTypeOf :: Either a b -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r #

gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) #

Data p => Data (V1 p)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 p -> c (V1 p) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V1 p) #

toConstr :: V1 p -> Constr #

dataTypeOf :: V1 p -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (V1 p)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V1 p)) #

gmapT :: (forall b. Data b => b -> b) -> V1 p -> V1 p #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V1 p -> r #

gmapQ :: (forall d. Data d => d -> u) -> V1 p -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> V1 p -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 p -> m (V1 p) #

Data p => Data (U1 p)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> U1 p -> c (U1 p) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (U1 p) #

toConstr :: U1 p -> Constr #

dataTypeOf :: U1 p -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (U1 p)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (U1 p)) #

gmapT :: (forall b. Data b => b -> b) -> U1 p -> U1 p #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> U1 p -> r #

gmapQ :: (forall d. Data d => d -> u) -> U1 p -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> U1 p -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 p -> m (U1 p) #

(Data a, Data b) => Data (a, b)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a, b) -> c (a, b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b) #

toConstr :: (a, b) -> Constr #

dataTypeOf :: (a, b) -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a, b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a, b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b) -> (a, b) #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r #

gmapQ :: (forall d. Data d => d -> u) -> (a, b) -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b) -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) #

(Data a, Data b, Ix a) => Data (Array a b)

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Array a b -> c (Array a b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array a b) #

toConstr :: Array a b -> Constr #

dataTypeOf :: Array a b -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Array a b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> Array a b -> Array a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r #

gmapQ :: (forall d. Data d => d -> u) -> Array a b -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Array a b -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) #

(Data a, Data b) => Data (Arg a b)

Since: base-4.9.0.0

Instance details

Defined in Data.Semigroup

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Arg a b -> c (Arg a b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Arg a b) #

toConstr :: Arg a b -> Constr #

dataTypeOf :: Arg a b -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Arg a b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> Arg a b -> Arg a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r #

gmapQ :: (forall d. Data d => d -> u) -> Arg a b -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Arg a b -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) #

(Typeable m, Typeable a, Data (m a)) => Data (WrappedMonad m a)

Since: base-4.14.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonad m a -> c (WrappedMonad m a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonad m a) #

toConstr :: WrappedMonad m a -> Constr #

dataTypeOf :: WrappedMonad m a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonad m a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonad m a)) #

gmapT :: (forall b. Data b => b -> b) -> WrappedMonad m a -> WrappedMonad m a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonad m a -> r #

gmapQ :: (forall d. Data d => d -> u) -> WrappedMonad m a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonad m a -> u #

gmapM :: Monad m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) #

gmapMp :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) #

gmapMo :: MonadPlus m0 => (forall d. Data d => d -> m0 d) -> WrappedMonad m a -> m0 (WrappedMonad m a) #

Data t => Data (Proxy t)

Since: base-4.7.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy t -> c (Proxy t) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy t) #

toConstr :: Proxy t -> Constr #

dataTypeOf :: Proxy t -> DataType #

dataCast1 :: Typeable t0 => (forall d. Data d => c (t0 d)) -> Maybe (c (Proxy t)) #

dataCast2 :: Typeable t0 => (forall d e. (Data d, Data e) => c (t0 d e)) -> Maybe (c (Proxy t)) #

gmapT :: (forall b. Data b => b -> b) -> Proxy t -> Proxy t #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy t -> r #

gmapQ :: (forall d. Data d => d -> u) -> Proxy t -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy t -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy t -> m (Proxy t) #

(Data k, Data a, Ord k) => Data (Map k a) 
Instance details

Defined in Data.Map.Internal

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Map k a -> c (Map k a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Map k a) #

toConstr :: Map k a -> Constr #

dataTypeOf :: Map k a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Map k a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Map k a)) #

gmapT :: (forall b. Data b => b -> b) -> Map k a -> Map k a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Map k a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Map k a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #

(Typeable s, Typeable a) => Data (SmallMutableArray s a) 
Instance details

Defined in Data.Primitive.SmallArray

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SmallMutableArray s a -> c (SmallMutableArray s a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SmallMutableArray s a) #

toConstr :: SmallMutableArray s a -> Constr #

dataTypeOf :: SmallMutableArray s a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (SmallMutableArray s a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SmallMutableArray s a)) #

gmapT :: (forall b. Data b => b -> b) -> SmallMutableArray s a -> SmallMutableArray s a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SmallMutableArray s a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SmallMutableArray s a -> r #

gmapQ :: (forall d. Data d => d -> u) -> SmallMutableArray s a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SmallMutableArray s a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SmallMutableArray s a -> m (SmallMutableArray s a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallMutableArray s a -> m (SmallMutableArray s a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SmallMutableArray s a -> m (SmallMutableArray s a) #

(Typeable s, Typeable a) => Data (MutableArray s a) 
Instance details

Defined in Data.Primitive.Array

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MutableArray s a -> c (MutableArray s a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (MutableArray s a) #

toConstr :: MutableArray s a -> Constr #

dataTypeOf :: MutableArray s a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (MutableArray s a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (MutableArray s a)) #

gmapT :: (forall b. Data b => b -> b) -> MutableArray s a -> MutableArray s a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MutableArray s a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MutableArray s a -> r #

gmapQ :: (forall d. Data d => d -> u) -> MutableArray s a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MutableArray s a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MutableArray s a -> m (MutableArray s a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableArray s a -> m (MutableArray s a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MutableArray s a -> m (MutableArray s a) #

(Data (f p), Typeable f, Data p) => Data (Rec1 f p)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rec1 f p -> c (Rec1 f p) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rec1 f p) #

toConstr :: Rec1 f p -> Constr #

dataTypeOf :: Rec1 f p -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Rec1 f p)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rec1 f p)) #

gmapT :: (forall b. Data b => b -> b) -> Rec1 f p -> Rec1 f p #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 f p -> r #

gmapQ :: (forall d. Data d => d -> u) -> Rec1 f p -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rec1 f p -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 f p -> m (Rec1 f p) #

(Data a, Data b, Data c) => Data (a, b, c)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c) -> c0 (a, b, c) #

gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c) #

toConstr :: (a, b, c) -> Constr #

dataTypeOf :: (a, b, c) -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (a, b, c)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (a, b, c)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c) -> (a, b, c) #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r #

gmapQ :: (forall d. Data d => d -> u) -> (a, b, c) -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b, c) -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) #

(Typeable a, Typeable b, Typeable c, Data (a b c)) => Data (WrappedArrow a b c)

Since: base-4.14.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c0 (d -> b0) -> d -> c0 b0) -> (forall g. g -> c0 g) -> WrappedArrow a b c -> c0 (WrappedArrow a b c) #

gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (WrappedArrow a b c) #

toConstr :: WrappedArrow a b c -> Constr #

dataTypeOf :: WrappedArrow a b c -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (WrappedArrow a b c)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (WrappedArrow a b c)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> WrappedArrow a b c -> WrappedArrow a b c #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedArrow a b c -> r #

gmapQ :: (forall d. Data d => d -> u) -> WrappedArrow a b c -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedArrow a b c -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedArrow a b c -> m (WrappedArrow a b c) #

(Typeable k, Data a, Typeable b) => Data (Const a b)

Since: base-4.10.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Const a b -> c (Const a b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Const a b) #

toConstr :: Const a b -> Constr #

dataTypeOf :: Const a b -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Const a b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Const a b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> Const a b -> Const a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const a b -> r #

gmapQ :: (forall d. Data d => d -> u) -> Const a b -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Const a b -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const a b -> m (Const a b) #

(Data (f a), Data a, Typeable f) => Data (Ap f a)

Since: base-4.12.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ap f a -> c (Ap f a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ap f a) #

toConstr :: Ap f a -> Constr #

dataTypeOf :: Ap f a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ap f a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ap f a)) #

gmapT :: (forall b. Data b => b -> b) -> Ap f a -> Ap f a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ap f a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Ap f a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ap f a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ap f a -> m (Ap f a) #

(Data (f a), Data a, Typeable f) => Data (Alt f a)

Since: base-4.8.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt f a -> c (Alt f a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt f a) #

toConstr :: Alt f a -> Constr #

dataTypeOf :: Alt f a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt f a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt f a)) #

gmapT :: (forall b. Data b => b -> b) -> Alt f a -> Alt f a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Alt f a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt f a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) #

(Coercible a b, Data a, Data b) => Data (Coercion a b)

Since: base-4.7.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Coercion a b -> c (Coercion a b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Coercion a b) #

toConstr :: Coercion a b -> Constr #

dataTypeOf :: Coercion a b -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Coercion a b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Coercion a b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> Coercion a b -> Coercion a b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion a b -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion a b -> r #

gmapQ :: (forall d. Data d => d -> u) -> Coercion a b -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion a b -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion a b -> m (Coercion a b) #

(a ~ b, Data a) => Data (a :~: b)

Since: base-4.7.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~: b) -> c (a :~: b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~: b) #

toConstr :: (a :~: b) -> Constr #

dataTypeOf :: (a :~: b) -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~: b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~: b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~: b) -> a :~: b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~: b) -> r #

gmapQ :: (forall d. Data d => d -> u) -> (a :~: b) -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~: b) -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~: b) -> m (a :~: b) #

(Typeable i, Data p, Data c) => Data (K1 i c p)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> K1 i c p -> c0 (K1 i c p) #

gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (K1 i c p) #

toConstr :: K1 i c p -> Constr #

dataTypeOf :: K1 i c p -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (K1 i c p)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (K1 i c p)) #

gmapT :: (forall b. Data b => b -> b) -> K1 i c p -> K1 i c p #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> K1 i c p -> r #

gmapQ :: (forall d. Data d => d -> u) -> K1 i c p -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> K1 i c p -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 i c p -> m (K1 i c p) #

(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :+: g) p)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :+: g) p -> c ((f :+: g) p) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :+: g) p) #

toConstr :: (f :+: g) p -> Constr #

dataTypeOf :: (f :+: g) p -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :+: g) p)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :+: g) p)) #

gmapT :: (forall b. Data b => b -> b) -> (f :+: g) p -> (f :+: g) p #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :+: g) p -> r #

gmapQ :: (forall d. Data d => d -> u) -> (f :+: g) p -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :+: g) p -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :+: g) p -> m ((f :+: g) p) #

(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :*: g) p)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :*: g) p -> c ((f :*: g) p) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :*: g) p) #

toConstr :: (f :*: g) p -> Constr #

dataTypeOf :: (f :*: g) p -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :*: g) p)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :*: g) p)) #

gmapT :: (forall b. Data b => b -> b) -> (f :*: g) p -> (f :*: g) p #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :*: g) p -> r #

gmapQ :: (forall d. Data d => d -> u) -> (f :*: g) p -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :*: g) p -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :*: g) p -> m ((f :*: g) p) #

(Data a, Data b, Data c, Data d) => Data (a, b, c, d)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d) -> c0 (a, b, c, d) #

gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d) #

toConstr :: (a, b, c, d) -> Constr #

dataTypeOf :: (a, b, c, d) -> DataType #

dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d)) #

dataCast2 :: Typeable t => (forall d0 e. (Data d0, Data e) => c0 (t d0 e)) -> Maybe (c0 (a, b, c, d)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d) -> (a, b, c, d) #

gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d) -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d) -> r #

gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d) -> [u] #

gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d) -> u #

gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) #

gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) #

gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d) -> m (a, b, c, d) #

(Typeable a, Typeable f, Typeable g, Typeable k, Data (f a), Data (g a)) => Data (Product f g a)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Product

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Product f g a -> c (Product f g a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product f g a) #

toConstr :: Product f g a -> Constr #

dataTypeOf :: Product f g a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Product f g a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product f g a)) #

gmapT :: (forall b. Data b => b -> b) -> Product f g a -> Product f g a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product f g a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product f g a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Product f g a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Product f g a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product f g a -> m (Product f g a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product f g a -> m (Product f g a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product f g a -> m (Product f g a) #

(Typeable a, Typeable f, Typeable g, Typeable k, Data (f a), Data (g a)) => Data (Sum f g a)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Sum

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Sum f g a -> c (Sum f g a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum f g a) #

toConstr :: Sum f g a -> Constr #

dataTypeOf :: Sum f g a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum f g a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum f g a)) #

gmapT :: (forall b. Data b => b -> b) -> Sum f g a -> Sum f g a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum f g a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum f g a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Sum f g a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum f g a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum f g a -> m (Sum f g a) #

(Typeable i, Typeable j, Typeable a, Typeable b, a ~~ b) => Data (a :~~: b)

Since: base-4.10.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> (a :~~: b) -> c (a :~~: b) #

gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a :~~: b) #

toConstr :: (a :~~: b) -> Constr #

dataTypeOf :: (a :~~: b) -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (a :~~: b)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a :~~: b)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a :~~: b) -> a :~~: b #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a :~~: b) -> r #

gmapQ :: (forall d. Data d => d -> u) -> (a :~~: b) -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (a :~~: b) -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a :~~: b) -> m (a :~~: b) #

(Data p, Data (f p), Typeable c, Typeable i, Typeable f) => Data (M1 i c f p)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> M1 i c f p -> c0 (M1 i c f p) #

gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (M1 i c f p) #

toConstr :: M1 i c f p -> Constr #

dataTypeOf :: M1 i c f p -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c0 (t d)) -> Maybe (c0 (M1 i c f p)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (M1 i c f p)) #

gmapT :: (forall b. Data b => b -> b) -> M1 i c f p -> M1 i c f p #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> M1 i c f p -> r #

gmapQ :: (forall d. Data d => d -> u) -> M1 i c f p -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> M1 i c f p -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 i c f p -> m (M1 i c f p) #

(Typeable f, Typeable g, Data p, Data (f (g p))) => Data ((f :.: g) p)

Since: base-4.9.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :.: g) p -> c ((f :.: g) p) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((f :.: g) p) #

toConstr :: (f :.: g) p -> Constr #

dataTypeOf :: (f :.: g) p -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ((f :.: g) p)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((f :.: g) p)) #

gmapT :: (forall b. Data b => b -> b) -> (f :.: g) p -> (f :.: g) p #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (f :.: g) p -> r #

gmapQ :: (forall d. Data d => d -> u) -> (f :.: g) p -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (f :.: g) p -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (f :.: g) p -> m ((f :.: g) p) #

(Data a, Data b, Data c, Data d, Data e) => Data (a, b, c, d, e)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d, e) -> c0 (a, b, c, d, e) #

gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e) #

toConstr :: (a, b, c, d, e) -> Constr #

dataTypeOf :: (a, b, c, d, e) -> DataType #

dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e)) #

dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e) -> (a, b, c, d, e) #

gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e) -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e) -> r #

gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e) -> [u] #

gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e) -> u #

gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) #

gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) #

gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e) -> m (a, b, c, d, e) #

(Typeable a, Typeable f, Typeable g, Typeable k1, Typeable k2, Data (f (g a))) => Data (Compose f g a)

Since: base-4.9.0.0

Instance details

Defined in Data.Functor.Compose

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> Compose f g a -> c (Compose f g a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Compose f g a) #

toConstr :: Compose f g a -> Constr #

dataTypeOf :: Compose f g a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Compose f g a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Compose f g a)) #

gmapT :: (forall b. Data b => b -> b) -> Compose f g a -> Compose f g a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Compose f g a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Compose f g a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Compose f g a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose f g a -> m (Compose f g a) #

(Data a, Data b, Data c, Data d, Data e, Data f) => Data (a, b, c, d, e, f)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g. g -> c0 g) -> (a, b, c, d, e, f) -> c0 (a, b, c, d, e, f) #

gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e, f) #

toConstr :: (a, b, c, d, e, f) -> Constr #

dataTypeOf :: (a, b, c, d, e, f) -> DataType #

dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e, f)) #

dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e, f)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) #

gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f) -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f) -> r #

gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f) -> [u] #

gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f) -> u #

gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) #

gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) #

gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) #

(Data a, Data b, Data c, Data d, Data e, Data f, Data g) => Data (a, b, c, d, e, f, g)

Since: base-4.0.0.0

Instance details

Defined in Data.Data

Methods

gfoldl :: (forall d0 b0. Data d0 => c0 (d0 -> b0) -> d0 -> c0 b0) -> (forall g0. g0 -> c0 g0) -> (a, b, c, d, e, f, g) -> c0 (a, b, c, d, e, f, g) #

gunfold :: (forall b0 r. Data b0 => c0 (b0 -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (a, b, c, d, e, f, g) #

toConstr :: (a, b, c, d, e, f, g) -> Constr #

dataTypeOf :: (a, b, c, d, e, f, g) -> DataType #

dataCast1 :: Typeable t => (forall d0. Data d0 => c0 (t d0)) -> Maybe (c0 (a, b, c, d, e, f, g)) #

dataCast2 :: Typeable t => (forall d0 e0. (Data d0, Data e0) => c0 (t d0 e0)) -> Maybe (c0 (a, b, c, d, e, f, g)) #

gmapT :: (forall b0. Data b0 => b0 -> b0) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) #

gmapQl :: (r -> r' -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f, g) -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d0. Data d0 => d0 -> r') -> (a, b, c, d, e, f, g) -> r #

gmapQ :: (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f, g) -> [u] #

gmapQi :: Int -> (forall d0. Data d0 => d0 -> u) -> (a, b, c, d, e, f, g) -> u #

gmapM :: Monad m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) #

gmapMp :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) #

gmapMo :: MonadPlus m => (forall d0. Data d0 => d0 -> m d0) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) #

class Typeable (a :: k) #

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

openLocalStateFrom #

Arguments

:: (IsAcidic st, SafeCopy st) 
=> FilePath

Location of the checkpoint and transaction files.

-> st

Initial state value. This value is only used if no checkpoint is found.

-> IO (AcidState st) 

Create an AcidState given a log directory and an initial value.

This will create or resume a log found in directory. Running two AcidState's from the same directory is an error but will not result in dataloss.

openLocalState #

Arguments

:: (Typeable st, IsAcidic st, SafeCopy st) 
=> st

Initial state value. This value is only used if no checkpoint is found.

-> IO (AcidState st) 

Create an AcidState given an initial value.

This will create or resume a log found in the "state/[typeOf state]/" directory.

makeAcidic :: Name -> [Name] -> Q [Dec] #

Create the control structures required for acid states using Template Haskell.

This code:

myUpdate :: Argument -> Update State Result
myUpdate arg = ...

myQuery :: Argument -> Query State Result
myQuery arg = ...

$(makeAcidic ''State ['myUpdate, 'myQuery])

will make State an instance of IsAcidic and provide the following events:

data MyUpdate = MyUpdate Argument
data MyQuery  = MyQuery Argument

data AcidState st #

State container offering full ACID (Atomicity, Consistency, Isolation and Durability) guarantees.

Atomicity
State changes are all-or-nothing. This is what you'd expect of any state variable in Haskell and AcidState doesn't change that.
Consistency
No event or set of events will break your data invariants.
Isolation
Transactions cannot interfere with each other even when issued in parallel.
Durability
Successful transaction are guaranteed to survive unexpected system shutdowns (both those caused by hardware and software).

Instances

Instances details
(Functor m, Monad m) => HasAcidState (FoundationT url (AcidState acidState) requestState m) acidState Source # 
Instance details

Defined in Happstack.Foundation

Methods

getAcidState :: FoundationT url (AcidState acidState) requestState m (AcidState acidState) Source #

liftQuery :: Query st a -> Update st a #

Run a query in the Update Monad.

class IsAcidic st #

Minimal complete definition

acidEvents

data Update st a #

Context monad for Update events.

Instances

Instances details
MonadState st (Update st) 
Instance details

Defined in Data.Acid.Common

Methods

get :: Update st st #

put :: st -> Update st () #

state :: (st -> (a, st)) -> Update st a #

Monad (Update st) 
Instance details

Defined in Data.Acid.Common

Methods

(>>=) :: Update st a -> (a -> Update st b) -> Update st b #

(>>) :: Update st a -> Update st b -> Update st b #

return :: a -> Update st a #

Functor (Update st) 
Instance details

Defined in Data.Acid.Common

Methods

fmap :: (a -> b) -> Update st a -> Update st b #

(<$) :: a -> Update st b -> Update st a #

Applicative (Update st) 
Instance details

Defined in Data.Acid.Common

Methods

pure :: a -> Update st a #

(<*>) :: Update st (a -> b) -> Update st a -> Update st b #

liftA2 :: (a -> b -> c) -> Update st a -> Update st b -> Update st c #

(*>) :: Update st a -> Update st b -> Update st b #

(<*) :: Update st a -> Update st b -> Update st a #

data Query st a #

Context monad for Query events.

Instances

Instances details
MonadReader st (Query st) 
Instance details

Defined in Data.Acid.Common

Methods

ask :: Query st st #

local :: (st -> st) -> Query st a -> Query st a #

reader :: (st -> a) -> Query st a #

Monad (Query st) 
Instance details

Defined in Data.Acid.Common

Methods

(>>=) :: Query st a -> (a -> Query st b) -> Query st b #

(>>) :: Query st a -> Query st b -> Query st b #

return :: a -> Query st a #

Functor (Query st) 
Instance details

Defined in Data.Acid.Common

Methods

fmap :: (a -> b) -> Query st a -> Query st b #

(<$) :: a -> Query st b -> Query st a #

Applicative (Query st) 
Instance details

Defined in Data.Acid.Common

Methods

pure :: a -> Query st a #

(<*>) :: Query st (a -> b) -> Query st a -> Query st b #

liftA2 :: (a -> b -> c) -> Query st a -> Query st b -> Query st c #

(*>) :: Query st a -> Query st b -> Query st b #

(<*) :: Query st a -> Query st b -> Query st a #

type EventResult ev = MethodResult ev #

Events return the same thing as Methods. The exact type of EventResult depends on the event.

type EventState ev = MethodState ev #

class Method ev => UpdateEvent ev #

All UpdateEvents are also Methods.

class Method ev => QueryEvent ev #

All QueryEvents are also Methods.

unXMLGenT :: XMLGenT m a -> m a #

un-lift.

newtype XMLGenT (m :: Type -> Type) a #

The monad transformer that allows a monad to generate XML values.

Constructors

XMLGenT (m a) 

Instances

Instances details
MonadTrans XMLGenT 
Instance details

Defined in HSP.XMLGenerator

Methods

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

(MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

MonadReader r m => MonadReader r (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

ask :: XMLGenT m r #

local :: (r -> r) -> XMLGenT m a -> XMLGenT m a #

reader :: (r -> a) -> XMLGenT m a #

MonadWriter w m => MonadWriter w (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

writer :: (a, w) -> XMLGenT m a #

tell :: w -> XMLGenT m () #

listen :: XMLGenT m a -> XMLGenT m (a, w) #

pass :: XMLGenT m (a, w -> w) -> XMLGenT m a #

MonadState s m => MonadState s (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

get :: XMLGenT m s #

put :: s -> XMLGenT m () #

state :: (s -> (a, s)) -> XMLGenT m a #

MonadError e m => MonadError e (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

throwError :: e -> XMLGenT m a #

catchError :: XMLGenT m a -> (e -> XMLGenT m a) -> XMLGenT m a #

(EmbedAsChild m c, m ~ n) => EmbedAsChild m (XMLGenT n c) 
Instance details

Defined in HSP.XMLGenerator

Methods

asChild :: XMLGenT n c -> GenChildList m #

(XMLGen m, EmbedAsAttr m a) => EmbedAsAttr m (XMLGenT m a) 
Instance details

Defined in HSP.XMLGenerator

Methods

asAttr :: XMLGenT m a -> GenAttributeList m #

(EmbedAsAttr m (Attr a v), TypeCastM m1 m) => EmbedAsAttr m (Attr a (XMLGenT m1 v)) 
Instance details

Defined in HSP.XMLGenerator

Methods

asAttr :: Attr a (XMLGenT m1 v) -> GenAttributeList m #

(TypeCastM m1 m, SetAttr m x) => SetAttr m (XMLGenT m1 x) 
Instance details

Defined in HSP.XMLGenerator

Methods

setAttr :: XMLGenT m1 x -> GenAttribute m -> GenXML m #

setAll :: XMLGenT m1 x -> GenAttributeList m -> GenXML m #

(AppendChild m x, TypeCastM m1 m) => AppendChild m (XMLGenT m1 x) 
Instance details

Defined in HSP.XMLGenerator

Methods

appChild :: XMLGenT m1 x -> GenChild m -> GenXML m #

appAll :: XMLGenT m1 x -> GenChildList m -> GenXML m #

Monad m => Monad (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

(>>=) :: XMLGenT m a -> (a -> XMLGenT m b) -> XMLGenT m b #

(>>) :: XMLGenT m a -> XMLGenT m b -> XMLGenT m b #

return :: a -> XMLGenT m a #

Functor m => Functor (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

fmap :: (a -> b) -> XMLGenT m a -> XMLGenT m b #

(<$) :: a -> XMLGenT m b -> XMLGenT m a #

Applicative m => Applicative (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

pure :: a -> XMLGenT m a #

(<*>) :: XMLGenT m (a -> b) -> XMLGenT m a -> XMLGenT m b #

liftA2 :: (a -> b -> c) -> XMLGenT m a -> XMLGenT m b -> XMLGenT m c #

(*>) :: XMLGenT m a -> XMLGenT m b -> XMLGenT m b #

(<*) :: XMLGenT m a -> XMLGenT m b -> XMLGenT m a #

MonadIO m => MonadIO (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

liftIO :: IO a -> XMLGenT m a #

Alternative m => Alternative (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

empty :: XMLGenT m a #

(<|>) :: XMLGenT m a -> XMLGenT m a -> XMLGenT m a #

some :: XMLGenT m a -> XMLGenT m [a] #

many :: XMLGenT m a -> XMLGenT m [a] #

MonadPlus m => MonadPlus (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

mzero :: XMLGenT m a #

mplus :: XMLGenT m a -> XMLGenT m a -> XMLGenT m a #

MonadCont m => MonadCont (XMLGenT m) 
Instance details

Defined in HSP.XMLGenerator

Methods

callCC :: ((a -> XMLGenT m b) -> XMLGenT m a) -> XMLGenT m a #

HasAcidState (FoundationT' url acid reqSt m) acidSt => HasAcidState (XMLGenT (FoundationT' url acid reqSt m)) acidSt Source # 
Instance details

Defined in Happstack.Foundation

Methods

getAcidState :: XMLGenT (FoundationT' url acid reqSt m) (AcidState acidSt) Source #

(Functor m, Monad m) => HasAcidState (FoundationT url (AcidState acidState) requestState m) acidState Source # 
Instance details

Defined in Happstack.Foundation

Methods

getAcidState :: FoundationT url (AcidState acidState) requestState m (AcidState acidState) Source #

type URL (XMLGenT m) 
Instance details

Defined in Web.Routes.XMLGenT

type URL (XMLGenT m) = URL m

data family AttributeType (m :: Type -> Type) #

Instances

Instances details
XMLGen m => EmbedAsAttr m (AttributeType m) 
Instance details

Defined in HSP.XMLGenerator

newtype AttributeType (HSPT XML m) 
Instance details

Defined in HSP.Monad

newtype AttributeType (RouteT url m) 
Instance details

Defined in Web.Routes.XMLGenT

newtype AttributeType (RouteT url m) = UAttr {}

data family ChildType (m :: Type -> Type) #

Instances

Instances details
XMLGen m => EmbedAsChild m (ChildType m) 
Instance details

Defined in HSP.XMLGenerator

Methods

asChild :: ChildType m -> GenChildList m #

newtype ChildType (HSPT XML m) 
Instance details

Defined in HSP.Monad

newtype ChildType (RouteT url m) 
Instance details

Defined in Web.Routes.XMLGenT

newtype ChildType (RouteT url m) = UChild {}

type family StringType (m :: Type -> Type) #

Instances

Instances details
type StringType (HSPT XML m) 
Instance details

Defined in HSP.Monad

type StringType (HSPT XML m) = Text
type StringType (RouteT url m) 
Instance details

Defined in Web.Routes.XMLGenT

type StringType (RouteT url m) = Text

type family XMLType (m :: Type -> Type) #

Instances

Instances details
type XMLType (HSPT XML m) 
Instance details

Defined in HSP.Monad

type XMLType (HSPT XML m) = XML
type XMLType (RouteT url m) 
Instance details

Defined in Web.Routes.XMLGenT

type XMLType (RouteT url m) = XML

class Monad m => XMLGen (m :: Type -> Type) where #

Generate XML values in some XMLGenerator monad.

Minimal complete definition

genElement, xmlToChild, pcdataToChild

Associated Types

type XMLType (m :: Type -> Type) #

type StringType (m :: Type -> Type) #

data ChildType (m :: Type -> Type) #

data AttributeType (m :: Type -> Type) #

Instances

Instances details
(Functor m, Monad m) => XMLGen (HSPT XML m) 
Instance details

Defined in HSP.Monad

Associated Types

type XMLType (HSPT XML m) #

type StringType (HSPT XML m) #

data ChildType (HSPT XML m) #

data AttributeType (HSPT XML m) #

class XMLGen m => EmbedAsChild (m :: Type -> Type) c where #

Embed values as child nodes of an XML element. The parent type will be clear from the context so it is not mentioned.

Methods

asChild :: c -> GenChildList m #

Instances

Instances details
(XMLGen m, XMLType m ~ x) => EmbedAsChild m x 
Instance details

Defined in HSP.XMLGenerator

Methods

asChild :: x -> GenChildList m #

XMLGen m => EmbedAsChild m () 
Instance details

Defined in HSP.XMLGenerator

Methods

asChild :: () -> GenChildList m #

EmbedAsChild m c => EmbedAsChild m [c] 
Instance details

Defined in HSP.XMLGenerator

Methods

asChild :: [c] -> GenChildList m #

XMLGen m => EmbedAsChild m (ChildType m) 
Instance details

Defined in HSP.XMLGenerator

Methods

asChild :: ChildType m -> GenChildList m #

(EmbedAsChild m c, m ~ n) => EmbedAsChild m (XMLGenT n c) 
Instance details

Defined in HSP.XMLGenerator

Methods

asChild :: XMLGenT n c -> GenChildList m #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) String 
Instance details

Defined in HSP.Monad

Methods

asChild :: String -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) XML 
Instance details

Defined in HSP.Monad

Methods

asChild :: XML -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) Text 
Instance details

Defined in HSP.Monad

Methods

asChild :: Text -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) Text 
Instance details

Defined in HSP.Monad

Methods

asChild :: Text -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) Char 
Instance details

Defined in HSP.Monad

Methods

asChild :: Char -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) () 
Instance details

Defined in HSP.Monad

Methods

asChild :: () -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) [XML] 
Instance details

Defined in HSP.Monad

Methods

asChild :: [XML] -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (FoundationT' url acidState requestState m) AppError Source # 
Instance details

Defined in Happstack.Foundation

Methods

asChild :: AppError -> GenChildList (FoundationT' url acidState requestState m) #

data Attr n a #

Constructors

n := a 

Instances

Instances details
(EmbedAsAttr m (Attr a v), TypeCastM m1 m) => EmbedAsAttr m (Attr a (XMLGenT m1 v)) 
Instance details

Defined in HSP.XMLGenerator

Methods

asAttr :: Attr a (XMLGenT m1 v) -> GenAttributeList m #

(Show n, Show a) => Show (Attr n a) 
Instance details

Defined in HSP.XMLGenerator

Methods

showsPrec :: Int -> Attr n a -> ShowS #

show :: Attr n a -> String #

showList :: [Attr n a] -> ShowS #

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Monad m, Functor m) => EmbedAsAttr (HSPT XML m) (Attr Text Char) 
Instance details

Defined in HSP.Monad

(Monad m, Functor m) => EmbedAsAttr (HSPT XML m) (Attr Text Char) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Bool) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Bool) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Int) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Int) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text ()) 
Instance details

Defined in HSP.Monad

Methods

asAttr :: Attr Text () -> GenAttributeList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text ()) 
Instance details

Defined in HSP.Monad

Methods

asAttr :: Attr Text () -> GenAttributeList (HSPT XML m) #

class XMLGen m => EmbedAsAttr (m :: Type -> Type) a where #

Similarly embed values as attributes of an XML element.

Methods

asAttr :: a -> GenAttributeList m #

Instances

Instances details
EmbedAsAttr m a => EmbedAsAttr m [a] 
Instance details

Defined in HSP.XMLGenerator

Methods

asAttr :: [a] -> GenAttributeList m #

XMLGen m => EmbedAsAttr m (AttributeType m) 
Instance details

Defined in HSP.XMLGenerator

(XMLGen m, EmbedAsAttr m a) => EmbedAsAttr m (XMLGenT m a) 
Instance details

Defined in HSP.XMLGenerator

Methods

asAttr :: XMLGenT m a -> GenAttributeList m #

(EmbedAsAttr m (Attr a v), TypeCastM m1 m) => EmbedAsAttr m (Attr a (XMLGenT m1 v)) 
Instance details

Defined in HSP.XMLGenerator

Methods

asAttr :: Attr a (XMLGenT m1 v) -> GenAttributeList m #

(Monad m, Functor m) => EmbedAsAttr (HSPT XML m) Attribute 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Monad m, Functor m) => EmbedAsAttr (HSPT XML m) (Attr Text Char) 
Instance details

Defined in HSP.Monad

(Monad m, Functor m) => EmbedAsAttr (HSPT XML m) (Attr Text Char) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Bool) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Bool) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Int) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Int) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text ()) 
Instance details

Defined in HSP.Monad

Methods

asAttr :: Attr Text () -> GenAttributeList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text ()) 
Instance details

Defined in HSP.Monad

Methods

asAttr :: Attr Text () -> GenAttributeList (HSPT XML m) #

class (XMLGen m, SetAttr m (XMLType m), AppendChild m (XMLType m), EmbedAsChild m (XMLType m), EmbedAsChild m [XMLType m], EmbedAsChild m Text, EmbedAsChild m Char, EmbedAsChild m (), EmbedAsAttr m (Attr Text Text), EmbedAsAttr m (Attr Text Int), EmbedAsAttr m (Attr Text Bool)) => XMLGenerator (m :: Type -> Type) #

Instances

Instances details
(Functor m, Monad m) => XMLGenerator (HSPT XML m) 
Instance details

Defined in HSP.Monad

data XML #

The XML datatype representation. Is either an Element or CDATA.

Instances

Instances details
Show XML 
Instance details

Defined in HSP.XML

Methods

showsPrec :: Int -> XML -> ShowS #

show :: XML -> String #

showList :: [XML] -> ShowS #

(Functor m, Monad m) => XMLGen (HSPT XML m) 
Instance details

Defined in HSP.Monad

Associated Types

type XMLType (HSPT XML m) #

type StringType (HSPT XML m) #

data ChildType (HSPT XML m) #

data AttributeType (HSPT XML m) #

(Functor m, Monad m) => XMLGenerator (HSPT XML m) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) String 
Instance details

Defined in HSP.Monad

Methods

asChild :: String -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) XML 
Instance details

Defined in HSP.Monad

Methods

asChild :: XML -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) Text 
Instance details

Defined in HSP.Monad

Methods

asChild :: Text -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) Text 
Instance details

Defined in HSP.Monad

Methods

asChild :: Text -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) Char 
Instance details

Defined in HSP.Monad

Methods

asChild :: Char -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) () 
Instance details

Defined in HSP.Monad

Methods

asChild :: () -> GenChildList (HSPT XML m) #

(Monad m, Functor m) => EmbedAsAttr (HSPT XML m) Attribute 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => SetAttr (HSPT XML m) XML 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => AppendChild (HSPT XML m) XML 
Instance details

Defined in HSP.Monad

Methods

appChild :: XML -> GenChild (HSPT XML m) -> GenXML (HSPT XML m) #

appAll :: XML -> GenChildList (HSPT XML m) -> GenXML (HSPT XML m) #

(Functor m, Monad m) => EmbedAsChild (HSPT XML m) [XML] 
Instance details

Defined in HSP.Monad

Methods

asChild :: [XML] -> GenChildList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Monad m, Functor m) => EmbedAsAttr (HSPT XML m) (Attr Text Char) 
Instance details

Defined in HSP.Monad

(Monad m, Functor m) => EmbedAsAttr (HSPT XML m) (Attr Text Char) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Bool) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Bool) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Int) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Text) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text Int) 
Instance details

Defined in HSP.Monad

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text ()) 
Instance details

Defined in HSP.Monad

Methods

asAttr :: Attr Text () -> GenAttributeList (HSPT XML m) #

(Functor m, Monad m) => EmbedAsAttr (HSPT XML m) (Attr Text ()) 
Instance details

Defined in HSP.Monad

Methods

asAttr :: Attr Text () -> GenAttributeList (HSPT XML m) #

newtype AttributeType (HSPT XML m) 
Instance details

Defined in HSP.Monad

newtype ChildType (HSPT XML m) 
Instance details

Defined in HSP.Monad

type StringType (HSPT XML m) 
Instance details

Defined in HSP.Monad

type StringType (HSPT XML m) = Text
type XMLType (HSPT XML m) 
Instance details

Defined in HSP.Monad

type XMLType (HSPT XML m) = XML

module Web.Routes

Internals

data AppError Source #

an error type used with reform forms

Instances

Instances details
IsString AppError Source # 
Instance details

Defined in Happstack.Foundation

FormError AppError Source # 
Instance details

Defined in Happstack.Foundation

Associated Types

type ErrorInputType AppError #

(Functor m, Monad m) => EmbedAsChild (FoundationT' url acidState requestState m) AppError Source # 
Instance details

Defined in Happstack.Foundation

Methods

asChild :: AppError -> GenChildList (FoundationT' url acidState requestState m) #

type ErrorInputType AppError Source # 
Instance details

Defined in Happstack.Foundation