Happstack.Foundation

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

Configuration

data AcidConfig st where

configuration information for our acid-state database

Constructors

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

AcidUsing :: st -> AcidConfig st

data FoundationConf

configuration for server

Constructors

FoundationConf

Fields

• httpConf :: Conf
• bodyPolicy :: BodyPolicy

defaultConf :: FoundationConf

configuration

Type Aliases

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

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

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

FoundationForm is an alias for working with reform based Forms

FoundationT functions

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

returns the decoded url from the Request

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

get the requestState value

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

set the requestState value

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

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

default page template

acid-state

class HasAcidState m st where

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

Minimal complete definition

getAcidState

Methods

getAcidState :: m (AcidState st)

Instances

HasAcidState (FoundationT' url acid reqSt m) acidSt => HasAcidState (XMLGenT (FoundationT' url acid reqSt m)) acidSt

Methods

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

(Functor m, Monad m) => HasAcidState (FoundationT url (AcidState acidState) requestState m) acidState

Methods

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

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

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)

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

running

simpleApp

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 :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> a -> c a

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 T a, dataCast1 should be defined as gcast1.

The default definition is const Nothing, which is appropriate for non-unary type constructors.

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 T a b, dataCast2 should be defined as gcast2.

The default definition is const Nothing, which is appropriate for non-binary type constructors.

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

Data Bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Methods

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

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

toConstr :: FamFlavour -> Constr

dataTypeOf :: FamFlavour -> DataType

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

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

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

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

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

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

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

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

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

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

Data Foreign

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 :: (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 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 :: (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 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 :: (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 a => Data [a]

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

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

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

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 :: (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 (V1 p)

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

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 :: (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 p => Data (Par1 p)

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

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

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 :: (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 (Identity a)

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 :: (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 (Min a)

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

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

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

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

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 :: (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 m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m)

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

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

Data a => Data (Option a)

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 :: (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 (NonEmpty a)

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 :: (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 (Complex a)

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 :: (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 (Dual a)

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

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

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 :: (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 (First a)

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

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 :: (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 (IntMap a)

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 :: (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 (Seq a)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 :: (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 (Binds l)

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

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

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

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

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

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

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

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

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

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

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

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

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

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 :: (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 (Promoted l)

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

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 :: (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 (Kind l)

Methods

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

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

toConstr :: Kind l -> Constr

dataTypeOf :: Kind l -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Kind l))

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

gmapT :: (forall b. Data b => b -> b) -> Kind l -> Kind l

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

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

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

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

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

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

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

Data l => Data (FunDep l)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Data a => Data (Array a)

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 :: (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 => Data (Vector a)

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

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 :: (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, Unbox a) => Data (Vector a)

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

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

Methods

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

gunfold :: (forall c r. Data c => c (c -> 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 c. Data c => c -> c) -> Either a b -> Either a b

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

gmapQr :: (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 (f p), Typeable (* -> *) f, Data p) => Data (Rec1 f p)

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 :: (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 (a, b)

Methods

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

gunfold :: (forall c r. Data c => c (c -> 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 c. Data c => c -> c) -> (a, b) -> (a, b)

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

gmapQr :: (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)

Methods

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

gunfold :: (forall c r. Data c => c (c -> 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 c. Data c => c -> c) -> Array a b -> Array a b

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

gmapQr :: (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 b, Data a) => Data (Arg a b)

Methods

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

gunfold :: (forall c r. Data c => c (c -> 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 c. Data c => c -> c) -> Arg a b -> Arg a b

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

gmapQr :: (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)

Data t => Data (Proxy * t)

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 (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Proxy * t))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t 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 :: (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)

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 :: (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 (MutableArray s a)

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

(Typeable * i, Data p, Data c) => Data (K1 i c p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> K1 i c p -> c (K1 i c p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (K1 i c p)

toConstr :: K1 i c p -> Constr

dataTypeOf :: K1 i c p -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (K1 i c p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (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 :: (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)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (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 :: (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)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (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 :: (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 (g p))) => Data ((:.:) f g p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (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 :: (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 (a, b, c)

Methods

gfoldl :: (forall d e. Data d => c (d -> e) -> d -> c e) -> (forall g. g -> c g) -> (a, b, c) -> c (a, b, c)

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

toConstr :: (a, b, c) -> Constr

dataTypeOf :: (a, b, c) -> DataType

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

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

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

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r

gmapQr :: (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)

(Data (f a), Data a, Typeable (* -> *) f) => Data (Alt * f a)

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

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Coercion * a b -> c (Coercion * a b)

gunfold :: (forall c r. Data c => c (c -> 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 c. Data c => c -> c) -> Coercion * a b -> Coercion * a b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion * a b -> r

gmapQr :: (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)

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> (* :~: a) b -> c ((* :~: a) b)

gunfold :: (forall c r. Data c => c (c -> 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 c. Data c => c -> c) -> (* :~: a) b -> (* :~: a) b

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :~: a) b -> r

gmapQr :: (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 Meta c, Typeable * i, Typeable (* -> *) f) => Data (M1 i c f p)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> M1 i c f p -> c (M1 i c f p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (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 => c (t d)) -> Maybe (c (M1 i c f p))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (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 :: (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)

(Data a, Data b, Data c, Data d) => Data (a, b, c, d)

Methods

gfoldl :: (forall e f. Data e => c (e -> f) -> e -> c f) -> (forall g. g -> c g) -> (a, b, c, d) -> c (a, b, c, d)

gunfold :: (forall e r. Data e => c (e -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b, c, d)

toConstr :: (a, b, c, d) -> Constr

dataTypeOf :: (a, b, c, d) -> DataType

dataCast1 :: Typeable (* -> *) t => (forall e. Data e => c (t e)) -> Maybe (c (a, b, c, d))

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

gmapT :: (forall e. Data e => e -> e) -> (a, b, c, d) -> (a, b, c, d)

gmapQl :: (r -> r' -> r) -> r -> (forall e. Data e => e -> r') -> (a, b, c, d) -> r

gmapQr :: (r' -> r -> r) -> r -> (forall e. Data e => e -> r') -> (a, b, c, d) -> r

gmapQ :: (forall e. Data e => e -> u) -> (a, b, c, d) -> [u]

gmapQi :: Int -> (forall e. Data e => e -> u) -> (a, b, c, d) -> u

gmapM :: Monad m => (forall e. Data e => e -> m e) -> (a, b, c, d) -> m (a, b, c, d)

gmapMp :: MonadPlus m => (forall e. Data e => e -> m e) -> (a, b, c, d) -> m (a, b, c, d)

gmapMo :: MonadPlus m => (forall e. Data e => e -> m e) -> (a, b, c, d) -> m (a, b, c, d)

(Data (g a), Data (f a), Typeable * k, Typeable (k -> *) g, Typeable (k -> *) f, Typeable k a) => Data (Sum k f g a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall b. b -> c b) -> Sum k f g a -> c (Sum k f g a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum k f g a)

toConstr :: Sum k f g a -> Constr

dataTypeOf :: Sum k f g a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Sum k f g a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum k f g a))

gmapT :: (forall b. Data b => b -> b) -> Sum k f g a -> Sum k f g a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum k f g a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum k f g a -> r

gmapQ :: (forall d. Data d => d -> u) -> Sum k f g a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum k f g a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum k f g a -> m (Sum k f g a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum k f g a -> m (Sum k f g a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum k f g a -> m (Sum k f g a)

(Data (g a), Data (f a), Typeable * k, Typeable (k -> *) g, Typeable (k -> *) f, Typeable k a) => Data (Product k f g a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall b. b -> c b) -> Product k f g a -> c (Product k f g a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product k f g a)

toConstr :: Product k f g a -> Constr

dataTypeOf :: Product k f g a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Product k f g a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product k f g a))

gmapT :: (forall b. Data b => b -> b) -> Product k f g a -> Product k f g a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product k f g a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product k f g a -> r

gmapQ :: (forall d. Data d => d -> u) -> Product k f g a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Product k f g a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product k f g a -> m (Product k f g a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product k f g a -> m (Product k f g a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product k f g a -> m (Product k f g a)

(Data a, Data b, Data c, Data d, Data e) => Data (a, b, c, d, e)

Methods

gfoldl :: (forall f g. Data f => c (f -> g) -> f -> c g) -> (forall g. g -> c g) -> (a, b, c, d, e) -> c (a, b, c, d, e)

gunfold :: (forall f r. Data f => c (f -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b, c, d, e)

toConstr :: (a, b, c, d, e) -> Constr

dataTypeOf :: (a, b, c, d, e) -> DataType

dataCast1 :: Typeable (* -> *) t => (forall f. Data f => c (t f)) -> Maybe (c (a, b, c, d, e))

dataCast2 :: Typeable (* -> * -> *) t => (forall f g. (Data f, Data g) => c (t f g)) -> Maybe (c (a, b, c, d, e))

gmapT :: (forall f. Data f => f -> f) -> (a, b, c, d, e) -> (a, b, c, d, e)

gmapQl :: (r -> r' -> r) -> r -> (forall f. Data f => f -> r') -> (a, b, c, d, e) -> r

gmapQr :: (r' -> r -> r) -> r -> (forall f. Data f => f -> r') -> (a, b, c, d, e) -> r

gmapQ :: (forall f. Data f => f -> u) -> (a, b, c, d, e) -> [u]

gmapQi :: Int -> (forall f. Data f => f -> u) -> (a, b, c, d, e) -> u

gmapM :: Monad m => (forall f. Data f => f -> m f) -> (a, b, c, d, e) -> m (a, b, c, d, e)

gmapMp :: MonadPlus m => (forall f. Data f => f -> m f) -> (a, b, c, d, e) -> m (a, b, c, d, e)

gmapMo :: MonadPlus m => (forall f. Data f => f -> m f) -> (a, b, c, d, e) -> m (a, b, c, d, e)

(Data (f (g a)), Typeable * k, Typeable * k1, Typeable (k1 -> k) g, Typeable (k -> *) f, Typeable k1 a) => Data (Compose k1 k f g a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall b. b -> c b) -> Compose k1 k f g a -> c (Compose k1 k f g a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Compose k1 k f g a)

toConstr :: Compose k1 k f g a -> Constr

dataTypeOf :: Compose k1 k f g a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Compose k1 k f g a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Compose k1 k f g a))

gmapT :: (forall b. Data b => b -> b) -> Compose k1 k f g a -> Compose k1 k f g a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Compose k1 k f g a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Compose k1 k f g a -> r

gmapQ :: (forall d. Data d => d -> u) -> Compose k1 k f g a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Compose k1 k f g a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Compose k1 k f g a -> m (Compose k1 k f g a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose k1 k f g a -> m (Compose k1 k f g a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose k1 k f g a -> m (Compose k1 k f g a)

(Data a, Data b, Data c, Data d, Data e, Data f) => Data (a, b, c, d, e, f)

Methods

gfoldl :: (forall g h. Data g => c (g -> h) -> g -> c h) -> (forall g. g -> c g) -> (a, b, c, d, e, f) -> c (a, b, c, d, e, f)

gunfold :: (forall g r. Data g => c (g -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (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 g. Data g => c (t g)) -> Maybe (c (a, b, c, d, e, f))

dataCast2 :: Typeable (* -> * -> *) t => (forall g h. (Data g, Data h) => c (t g h)) -> Maybe (c (a, b, c, d, e, f))

gmapT :: (forall g. Data g => g -> g) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

gmapQl :: (r -> r' -> r) -> r -> (forall g. Data g => g -> r') -> (a, b, c, d, e, f) -> r

gmapQr :: (r' -> r -> r) -> r -> (forall g. Data g => g -> r') -> (a, b, c, d, e, f) -> r

gmapQ :: (forall g. Data g => g -> u) -> (a, b, c, d, e, f) -> [u]

gmapQi :: Int -> (forall g. Data g => g -> u) -> (a, b, c, d, e, f) -> u

gmapM :: Monad m => (forall g. Data g => g -> m g) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f)

gmapMp :: MonadPlus m => (forall g. Data g => g -> m g) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f)

gmapMo :: MonadPlus m => (forall g. Data g => g -> m g) -> (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)

Methods

gfoldl :: (forall h i. Data h => c (h -> i) -> h -> c i) -> (forall h. h -> c h) -> (a, b, c, d, e, f, g) -> c (a, b, c, d, e, f, g)

gunfold :: (forall h r. Data h => c (h -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (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 h. Data h => c (t h)) -> Maybe (c (a, b, c, d, e, f, g))

dataCast2 :: Typeable (* -> * -> *) t => (forall h i. (Data h, Data i) => c (t h i)) -> Maybe (c (a, b, c, d, e, f, g))

gmapT :: (forall h. Data h => h -> h) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

gmapQl :: (r -> r' -> r) -> r -> (forall h. Data h => h -> r') -> (a, b, c, d, e, f, g) -> r

gmapQr :: (r' -> r -> r) -> r -> (forall h. Data h => h -> r') -> (a, b, c, d, e, f, g) -> r

gmapQ :: (forall h. Data h => h -> u) -> (a, b, c, d, e, f, g) -> [u]

gmapQi :: Int -> (forall h. Data h => h -> u) -> (a, b, c, d, e, f, g) -> u

gmapM :: Monad m => (forall h. Data h => h -> m h) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g)

gmapMp :: MonadPlus m => (forall h. Data h => h -> m h) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g)

gmapMo :: MonadPlus m => (forall h. Data h => h -> m h) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g)

class Typeable k a

The class Typeable allows a concrete representation of a type to be calculated.

Minimal complete definition

typeRep#

module Control.Applicative

module Control.Monad.Reader

module Control.Monad.State

module Data.SafeCopy

module Data.Acid

module Happstack.Server

module HSP

module Web.Routes

module Web.Routes.Happstack

module Web.Routes.TH

module Text.Reform

module Text.Reform.Happstack

module Text.Reform.HSP.Text

Internals

data AppError

an error type used with reform forms

Constructors

AppCFE (CommonFormError [Input])

TextError Text

Instances

IsString AppError

Methods

fromString :: String -> AppError

FormError AppError

Associated Types

type ErrorInputType AppError :: *

Methods

commonFormError :: CommonFormError (ErrorInputType AppError) -> AppError

(Functor m, Monad m) => EmbedAsChild (FoundationT' url acidState requestState m) AppError

Methods

asChild :: AppError -> GenChildList (FoundationT' url acidState requestState m)

type ErrorInputType AppError

type ErrorInputType AppError = [Input]