Copyright	(c) 2013-2018 Brendan Hay <brendan.g.hay+amazonka@gmail.com>
License	Mozilla Public License, v. 2.0.
Maintainer	Brendan Hay <brendan.g.hay+amazonka@gmail.com>
Stability	provisional
Portability	non-portable (GHC extensions)
Safe Haskell	None
Language	Haskell2010

Network.AWS.Prelude

Description

Synopsis

(.!@) :: Functor f => f (Maybe a) -> a -> f a
may :: Applicative f => ([a] -> f b) -> [a] -> f (Maybe b)
class Typeable a => Data a
class Typeable (a :: k)
class Functor f => Applicative (f :: Type -> Type) where
- pure :: a -> f a
- (<*>) :: f (a -> b) -> f a -> f b
class Foldable (t :: Type -> Type)
class Generic a
(<>) :: Semigroup a => a -> a -> a
mempty :: Monoid a => a
mconcat :: Monoid a => [a] -> a
data Natural
data Maybe a
- = Nothing
- | Just a
data ByteString
(<$>) :: Functor f => (a -> b) -> f a -> f b
class Hashable a
data Text
data UTCTime
data HashMap k v
eitherDecode' :: FromJSON a => ByteString -> Either String a
eitherDecode :: FromJSON a => ByteString -> Either String a
class ToJSON a where
- toJSON :: a -> Value
- toEncoding :: a -> Encoding
- toJSONList :: [a] -> Value
- toEncodingList :: [a] -> Encoding
(.=) :: (KeyValue kv, ToJSON v) => Text -> v -> kv
(.!=) :: Parser (Maybe a) -> a -> Parser a
(.:?) :: FromJSON a => Object -> Text -> Parser (Maybe a)
(.:) :: FromJSON a => Object -> Text -> Parser a
withObject :: String -> (Object -> Parser a) -> Value -> Parser a
class FromJSON a where
- parseJSON :: Value -> Parser a
- parseJSONList :: Value -> Parser [a]
object :: [Pair] -> Value
data Value = Object !Object
(<|>) :: Alternative f => f a -> f a -> f a
data First a
mapMaybe :: (a -> Maybe b) -> [a] -> [b]
catMaybes :: [Maybe a] -> [a]
listToMaybe :: [a] -> Maybe a
maybeToList :: Maybe a -> [a]
fromMaybe :: a -> Maybe a -> a
fromJust :: Maybe a -> a
isNothing :: Maybe a -> Bool
isJust :: Maybe a -> Bool
maybe :: b -> (a -> b) -> Maybe a -> b
data NonEmpty a = a :| [a]
class NFData a
data HMAC a
hashFinalize :: HashAlgorithm a => Context a -> Digest a
hashUpdate :: (ByteArrayAccess ba, HashAlgorithm a) => Context a -> ba -> Context a
hashInit :: HashAlgorithm a => Context a
hashlazy :: HashAlgorithm a => ByteString -> Digest a
hash :: (ByteArrayAccess ba, HashAlgorithm a) => ba -> Digest a
data MD5 = MD5
data SHA256 = SHA256
class HashAlgorithm a
data Digest a
data HttpException
type Header = (HeaderName, ByteString)
urlDecode :: Bool -> ByteString -> ByteString
urlEncode :: Bool -> ByteString -> ByteString
data Status = Status {
- statusCode :: Int
- statusMessage :: ByteString
}
hContentType :: HeaderName
type HeaderName = CI ByteString
digestToBS :: ByteArrayAccess a => a -> ByteString
digestToBase :: ByteArrayAccess a => Base -> a -> ByteString
hmacSHA1 :: (ByteArrayAccess a, ByteArray b) => a -> b -> HMAC SHA1
hmacSHA256 :: (ByteArrayAccess a, ByteArray b) => a -> b -> HMAC SHA256
hashSHA256 :: ByteArrayAccess a => a -> Digest SHA256
hashMD5 :: ByteArrayAccess a => a -> Digest MD5
class ToText a where
- toText :: a -> Text
class FromText a where
- parser :: Parser a
fromTextError :: Text -> Parser a
fromText :: FromText a => Text -> Either String a
takeLowerText :: Parser Text
takeText :: Parser Text
showText :: ToText a => a -> String
toTextCI :: ToText a => a -> CI Text
parseJSONText :: FromText a => String -> Value -> Parser a
toJSONText :: ToText a => a -> Value
eitherParseJSON :: FromJSON a => Object -> Either String a
(.:>) :: FromJSON a => Object -> Text -> Either String a
(.?>) :: FromJSON a => Object -> Text -> Either String (Maybe a)
class ToByteString a where
- toBS :: a -> ByteString
type LazyByteString = ByteString
showBS :: ToByteString a => a -> String
stripBS :: ByteString -> ByteString
class ToQuery a where
- toQuery :: a -> QueryString
data QueryString
- = QList [QueryString]
- | QPair ByteString QueryString
- | QValue (Maybe ByteString)
parseQueryString :: ByteString -> QueryString
stripPrefix :: ByteString -> ByteString -> Maybe ByteString
pair :: ToQuery a => ByteString -> a -> QueryString -> QueryString
(=:) :: ToQuery a => ByteString -> a -> QueryString
toQueryList :: (IsList a, ToQuery (Item a)) => ByteString -> a -> QueryString
type EscapedPath = Path Percent
type RawPath = Path NoEncoding
class ToPath a where
- toPath :: a -> ByteString
rawPath :: ToPath a => a -> Path NoEncoding
escapePath :: Path a -> EscapedPath
collapsePath :: Path a -> Path a
class ToHeader a where
- toHeader :: HeaderName -> a -> [Header]
class ToHeaders a where
- toHeaders :: a -> [Header]
(.#) :: FromText a => ResponseHeaders -> HeaderName -> Either String a
(.#?) :: FromText a => ResponseHeaders -> HeaderName -> Either String (Maybe a)
(=#) :: ToHeader a => HeaderName -> a -> [Header]
hdr :: HeaderName -> ByteString -> [Header] -> [Header]
hHost :: HeaderName
hExpect :: HeaderName
hAMZToken :: HeaderName
hAMZTarget :: HeaderName
hAMZAlgorithm :: HeaderName
hAMZCredential :: HeaderName
hAMZExpires :: HeaderName
hAMZSignedHeaders :: HeaderName
hAMZContentSHA256 :: HeaderName
hAMZDate :: HeaderName
hMetaPrefix :: HeaderName
hAMZRequestId :: HeaderName
hAMZNRequestId :: HeaderName
hAMZNErrorType :: HeaderName
hAMZNAuth :: HeaderName
hAMZDecodedContentLength :: HeaderName
hTransferEncoding :: HeaderName
hFormEncoded :: ByteString
class ToXML a where
- toXML :: a -> XML
data XML
- = XNull
- | XAttr Name Text
- | XOne Node
- | XMany [(Name, Text)] [Node]
class ToElement a where
- toElement :: a -> Element
class FromXML a where
- parseXML :: [Node] -> Either String a
(.@) :: FromXML a => [Node] -> Text -> Either String a
(.@?) :: FromXML a => [Node] -> Text -> Either String (Maybe a)
(@=) :: ToXML a => Name -> a -> XML
(@@=) :: ToText a => Name -> a -> XML
decodeXML :: FromXML a => LazyByteString -> Either String a
encodeXML :: ToElement a => a -> LazyByteString
maybeElement :: ToElement a => a -> Maybe Element
listXMLNodes :: XML -> [Node]
listXMLAttributes :: XML -> [(Name, Text)]
parseXMLList :: FromXML a => Text -> [Node] -> Either String [a]
parseXMLText :: FromText a => String -> [Node] -> Either String a
toXMLList :: (IsList a, ToXML (Item a)) => Name -> a -> XML
toXMLText :: ToText a => a -> XML
mkElement :: ToXML a => Name -> a -> Element
withContent :: String -> [Node] -> Either String (Maybe Text)
findElement :: Text -> [Node] -> Either String [Node]
firstElement :: Text -> [Node] -> Either String [Node]
childNodesOf :: Text -> Node -> Maybe [Node]
childrenOf :: Element -> [Node]
localName :: Node -> Maybe Text
rootElementName :: LazyByteString -> Maybe Text
missingElement :: Text -> [Node] -> Maybe a -> Either String a
type POSIX = Time POSIXFormat
type AWSTime = Time AWSFormat
type BasicTime = Time BasicFormat
type ISO8601 = Time ISO8601Format
type RFC822 = Time RFC822Format
newtype Time (a :: Format) = Time {
- fromTime :: UTCTime
}
_Time :: Iso' (Time a) UTCTime
newtype Sensitive a = Sensitive {
- desensitise :: a
}
_Sensitive :: Iso' (Sensitive a) a
newtype Nat = Nat {
- unNat :: Natural
}
_Nat :: Iso' Nat Natural
newtype Map k v = Map {
- toMap :: HashMap k v
}
_Map :: (Coercible a b, Coercible b a) => Iso' (Map k a) (HashMap k b)
parseXMLMap :: (Eq k, Hashable k, FromText k, FromXML v) => Text -> Text -> Text -> [Node] -> Either String (Map k v)
parseHeadersMap :: FromText a => ByteString -> ResponseHeaders -> Either String (Map Text a)
toQueryMap :: (Hashable k, Eq k, ToQuery k, ToQuery v) => ByteString -> ByteString -> ByteString -> Map k v -> QueryString
newtype List1 a = List1 {
- toNonEmpty :: NonEmpty a
}
_List1 :: (Coercible a b, Coercible b a) => Iso' (List1 a) (NonEmpty b)
parseXMLList1 :: FromXML a => Text -> [Node] -> Either String (List1 a)
class ToBody a where
- toBody :: a -> RqBody
class ToHashedBody a where
- toHashed :: a -> HashedBody
data RqBody
- = Chunked ChunkedBody
- | Hashed HashedBody
data HashedBody
- = HashedStream (Digest SHA256) !Integer (ConduitM () ByteString (ResourceT IO) ())
- | HashedBytes (Digest SHA256) ByteString
data ChunkedBody = ChunkedBody {
- _chunkedSize :: !ChunkSize
- _chunkedLength :: !Integer
- _chunkedBody :: ConduitM () ByteString (ResourceT IO) ()
}
newtype ChunkSize = ChunkSize Int
newtype RsBody = RsBody {
- _streamBody :: ConduitM () ByteString (ResourceT IO) ()
}
fuseStream :: RsBody -> ConduitM ByteString ByteString (ResourceT IO) () -> RsBody
defaultChunkSize :: ChunkSize
chunkedLength :: Lens' ChunkedBody Integer
fuseChunks :: ChunkedBody -> ConduitM ByteString ByteString (ResourceT IO) () -> ChunkedBody
fullChunks :: ChunkedBody -> Integer
remainderBytes :: ChunkedBody -> Maybe Integer
sha256Base16 :: HashedBody -> ByteString
md5Base64 :: RqBody -> Maybe ByteString
isStreaming :: RqBody -> Bool
toRequestBody :: RqBody -> RequestBody
contentLength :: RqBody -> Integer
_Body :: ToBody a => AReview RqBody a
newtype Base64 = Base64 {
- unBase64 :: ByteString
}
_Base64 :: Iso' Base64 ByteString
data Region
- = NorthVirginia
- | Ohio
- | NorthCalifornia
- | Oregon
- | Montreal
- | Tokyo
- | Seoul
- | Mumbai
- | Singapore
- | Sydney
- | SaoPaulo
- | Ireland
- | London
- | Frankfurt
- | GovCloud
- | GovCloudFIPS
- | Beijing
data Auth
- = Ref ThreadId (IORef AuthEnv)
- | Auth AuthEnv
data AuthEnv = AuthEnv {
- _authAccess :: !AccessKey
- _authSecret :: !(Sensitive SecretKey)
- _authToken :: Maybe (Sensitive SessionToken)
- _authExpiry :: Maybe ISO8601
}
newtype SessionToken = SessionToken ByteString
newtype SecretKey = SecretKey ByteString
newtype AccessKey = AccessKey ByteString
class AWSRequest a where
- type Rs a :: *
- request :: a -> Request a
- response :: (MonadResource m, MonadThrow m) => Logger -> Service -> Proxy a -> ClientResponse -> m (Response a)
type Response a = (Status, Rs a)
data Request a = Request {
- _rqService :: !Service
- _rqMethod :: !StdMethod
- _rqPath :: !RawPath
- _rqQuery :: !QueryString
- _rqHeaders :: ![Header]
- _rqBody :: !RqBody
}
data Service = Service {
- _svcAbbrev :: !Abbrev
- _svcSigner :: !Signer
- _svcPrefix :: !ByteString
- _svcVersion :: !ByteString
- _svcEndpoint :: !(Region -> Endpoint)
- _svcTimeout :: !(Maybe Seconds)
- _svcCheck :: !(Status -> Bool)
- _svcError :: !(Status -> [Header] -> LazyByteString -> Error)
- _svcRetry :: !Retry
}
sgSign :: Signer -> forall a. Algorithm a
sgPresign :: Signer -> forall a. Seconds -> Algorithm a
data Signed a = Signed {
- sgMeta :: !Meta
- sgRequest :: !ClientRequest
}
data Meta where
- Meta :: ToLog a => a -> Meta
data Retry = Exponential {
- _retryBase :: !Double
- _retryGrowth :: !Int
- _retryAttempts :: !Int
- _retryCheck :: ServiceError -> Maybe Text
}
type Logger = LogLevel -> Builder -> IO ()
_endpointHost :: Endpoint -> ByteString
_endpointSecure :: Endpoint -> Bool
_endpointPort :: Endpoint -> Int
_endpointScope :: Endpoint -> ByteString
class AsError a where
- _Error :: Prism' a Error
- _TransportError :: Prism' a HttpException
- _SerializeError :: Prism' a SerializeError
- _ServiceError :: Prism' a ServiceError
data ServiceError = ServiceError' {
- _serviceAbbrev :: !Abbrev
- _serviceStatus :: !Status
- _serviceHeaders :: [Header]
- _serviceCode :: !ErrorCode
- _serviceMessage :: Maybe ErrorMessage
- _serviceRequestId :: Maybe RequestId
}
data SerializeError = SerializeError' {
- _serializeAbbrev :: !Abbrev
- _serializeStatus :: !Status
- _serializeBody :: Maybe LazyByteString
- _serializeMessage :: String
}
data Error
- = TransportError HttpException
- | SerializeError SerializeError
- | ServiceError ServiceError
newtype RequestId = RequestId Text
newtype ErrorMessage = ErrorMessage Text
newtype ErrorCode = ErrorCode Text
data Abbrev
type ResponseBody = ConduitM () ByteString (ResourceT IO) ()
type ClientResponse = Response ResponseBody
type ClientRequest = Request
errorCode :: Text -> ErrorCode
serializeAbbrev :: Lens' SerializeError Abbrev
serializeStatus :: Lens' SerializeError Status
serializeMessage :: Lens' SerializeError String
serviceAbbrev :: Lens' ServiceError Abbrev
serviceStatus :: Lens' ServiceError Status
serviceHeaders :: Lens' ServiceError [Header]
serviceCode :: Lens' ServiceError ErrorCode
serviceMessage :: Lens' ServiceError (Maybe ErrorMessage)
serviceRequestId :: Lens' ServiceError (Maybe RequestId)
endpointHost :: Lens' Endpoint ByteString
endpointSecure :: Lens' Endpoint Bool
endpointPort :: Lens' Endpoint Int
endpointScope :: Lens' Endpoint ByteString
exponentBase :: Lens' Retry Double
exponentGrowth :: Lens' Retry Int
retryAttempts :: Lens' Retry Int
retryCheck :: Lens' Retry (ServiceError -> Maybe Text)
serviceSigner :: Lens' Service Signer
serviceTimeout :: Lens' Service (Maybe Seconds)
serviceCheck :: Lens' Service (Status -> Bool)
serviceRetry :: Lens' Service Retry
clientRequest :: Endpoint -> Maybe Seconds -> ClientRequest
rqService :: Lens' (Request a) Service
rqBody :: Lens' (Request a) RqBody
rqHeaders :: Lens' (Request a) [Header]
rqMethod :: Lens' (Request a) StdMethod
rqPath :: Lens' (Request a) RawPath
rqQuery :: Lens' (Request a) QueryString
rqSign :: Algorithm a
rqPresign :: Seconds -> Algorithm a
accessKeyId :: Lens' AuthEnv AccessKey
secretAccessKey :: Lens' AuthEnv SecretKey
sessionToken :: Lens' AuthEnv (Maybe SessionToken)
expiration :: Lens' AuthEnv (Maybe UTCTime)
withAuth :: MonadIO m => Auth -> (AuthEnv -> m a) -> m a
seconds :: Seconds -> Int
microseconds :: Seconds -> Int
_Coerce :: (Coercible a b, Coercible b a) => Iso' a b
_Default :: Monoid a => Iso' (Maybe a) a
_MatchServiceError :: AsError a => Service -> ErrorCode -> Getting (First ServiceError) a ServiceError
statusSuccess :: Status -> Bool
httpStatus :: AsError a => Getting (First Status) a Status
hasService :: (Applicative f, Choice p) => Service -> Optic' p f ServiceError ServiceError
hasStatus :: (Applicative f, Choice p) => Int -> Optic' p f ServiceError ServiceError
hasCode :: (Applicative f, Choice p) => ErrorCode -> Optic' p f ServiceError ServiceError
serviceError :: Abbrev -> Status -> [Header] -> Maybe ErrorCode -> Maybe ErrorMessage -> Maybe RequestId -> ServiceError
getRequestId :: [Header] -> Maybe RequestId
getErrorCode :: Status -> [Header] -> ErrorCode
parseJSONError :: Abbrev -> Status -> [Header] -> LazyByteString -> Error
parseXMLError :: Abbrev -> Status -> [Header] -> LazyByteString -> Error
parseRESTError :: Abbrev -> Status -> [Header] -> a -> Error
decodeError :: Abbrev -> Status -> [Header] -> LazyByteString -> Either String ServiceError -> Error
setEndpoint :: Bool -> ByteString -> Int -> Service -> Service
defaultEndpoint :: Service -> Region -> Endpoint

Documentation

(.!@) :: Functor f => f (Maybe a) -> a -> f a infixl 7 Source #

may :: Applicative f => ([a] -> f b) -> [a] -> f (Maybe b) Source #

class Typeable a => Data a #

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

Instances

Data Bool	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool # toConstr :: Bool -> Constr # dataTypeOf :: Bool -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) # gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r # gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool #
Data Char	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char # toConstr :: Char -> Constr # dataTypeOf :: Char -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) # gmapT :: (forall b. Data b => b -> b) -> Char -> Char # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r # gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char #
Data Double	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double # toConstr :: Double -> Constr # dataTypeOf :: Double -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) # gmapT :: (forall b. Data b => b -> b) -> Double -> Double # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r # gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double #
Data Float	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float # toConstr :: Float -> Constr # dataTypeOf :: Float -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) # gmapT :: (forall b. Data b => b -> b) -> Float -> Float # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r # gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float #
Data Int	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int # toConstr :: Int -> Constr # dataTypeOf :: Int -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) # gmapT :: (forall b. Data b => b -> b) -> Int -> Int # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r # gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int #
Data Int8	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 # toConstr :: Int8 -> Constr # dataTypeOf :: Int8 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int8) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) # gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 #
Data Int16	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 # toConstr :: Int16 -> Constr # dataTypeOf :: Int16 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int16) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) # gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 #
Data Int32	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 # toConstr :: Int32 -> Constr # dataTypeOf :: Int32 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int32) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) # gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 #
Data Int64	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 # toConstr :: Int64 -> Constr # dataTypeOf :: Int64 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int64) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) # gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 #
Data Integer	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer # toConstr :: Integer -> Constr # dataTypeOf :: Integer -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) # gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r # gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer #
Data Natural	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural # toConstr :: Natural -> Constr # dataTypeOf :: Natural -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Natural) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural) # gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r # gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural #
Data Ordering	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering # toConstr :: Ordering -> Constr # dataTypeOf :: Ordering -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) # gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r # gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering #
Data Word	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word # toConstr :: Word -> Constr # dataTypeOf :: Word -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) # gmapT :: (forall b. Data b => b -> b) -> Word -> Word # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r # gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word #
Data Word8	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8 # toConstr :: Word8 -> Constr # dataTypeOf :: Word8 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word8) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8) # gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 #
Data Word16	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 # toConstr :: Word16 -> Constr # dataTypeOf :: Word16 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word16) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) # gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 #
Data Word32	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 # toConstr :: Word32 -> Constr # dataTypeOf :: Word32 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word32) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) # gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 #
Data Word64	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 # toConstr :: Word64 -> Constr # dataTypeOf :: Word64 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word64) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) # gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r # gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 #
Data Exp
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Exp -> c Exp # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Exp # toConstr :: Exp -> Constr # dataTypeOf :: Exp -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Exp) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Exp) # gmapT :: (forall b. Data b => b -> b) -> Exp -> Exp # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Exp -> r # gmapQ :: (forall d. Data d => d -> u) -> Exp -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Exp -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Exp -> m Exp # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Exp -> m Exp #
Data Match
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Match -> c Match # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Match # toConstr :: Match -> Constr # dataTypeOf :: Match -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Match) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match) # gmapT :: (forall b. Data b => b -> b) -> Match -> Match # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r # gmapQ :: (forall d. Data d => d -> u) -> Match -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Match -> m Match # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Match -> m Match #
Data Clause
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Clause -> c Clause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Clause # toConstr :: Clause -> Constr # dataTypeOf :: Clause -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Clause) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Clause) # gmapT :: (forall b. Data b => b -> b) -> Clause -> Clause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Clause -> r # gmapQ :: (forall d. Data d => d -> u) -> Clause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Clause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Clause -> m Clause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Clause -> m Clause #
Data Pat
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Pat -> c Pat # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Pat # toConstr :: Pat -> Constr # dataTypeOf :: Pat -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Pat) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pat) # gmapT :: (forall b. Data b => b -> b) -> Pat -> Pat # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pat -> r # gmapQ :: (forall d. Data d => d -> u) -> Pat -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Pat -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Pat -> m Pat # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Pat -> m Pat #
Data Type
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Type -> c Type # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Type # toConstr :: Type -> Constr # dataTypeOf :: Type -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Type) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Type) # gmapT :: (forall b. Data b => b -> b) -> Type -> Type # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Type -> r # gmapQ :: (forall d. Data d => d -> u) -> Type -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Type -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Type -> m Type #
Data Dec
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dec -> c Dec # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dec # toConstr :: Dec -> Constr # dataTypeOf :: Dec -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Dec) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dec) # gmapT :: (forall b. Data b => b -> b) -> Dec -> Dec # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dec -> r # gmapQ :: (forall d. Data d => d -> u) -> Dec -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Dec -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dec -> m Dec # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dec -> m Dec #
Data Name
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Name -> c Name # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Name # toConstr :: Name -> Constr # dataTypeOf :: Name -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Name) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name) # gmapT :: (forall b. Data b => b -> b) -> Name -> Name # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r # gmapQ :: (forall d. Data d => d -> u) -> Name -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Name -> m Name #
Data FunDep
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FunDep -> c FunDep # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FunDep # toConstr :: FunDep -> Constr # dataTypeOf :: FunDep -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FunDep) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FunDep) # gmapT :: (forall b. Data b => b -> b) -> FunDep -> FunDep # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FunDep -> r # gmapQ :: (forall d. Data d => d -> u) -> FunDep -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FunDep -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FunDep -> m FunDep #
Data InjectivityAnn
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> InjectivityAnn -> c InjectivityAnn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c InjectivityAnn # toConstr :: InjectivityAnn -> Constr # dataTypeOf :: InjectivityAnn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c InjectivityAnn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c InjectivityAnn) # gmapT :: (forall b. Data b => b -> b) -> InjectivityAnn -> InjectivityAnn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> InjectivityAnn -> r # gmapQ :: (forall d. Data d => d -> u) -> InjectivityAnn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> InjectivityAnn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> InjectivityAnn -> m InjectivityAnn #
Data Overlap
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Overlap -> c Overlap # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Overlap # toConstr :: Overlap -> Constr # dataTypeOf :: Overlap -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Overlap) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Overlap) # gmapT :: (forall b. Data b => b -> b) -> Overlap -> Overlap # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Overlap -> r # gmapQ :: (forall d. Data d => d -> u) -> Overlap -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Overlap -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Overlap -> m Overlap #
Data ()	Since: base-4.0.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> () -> c () # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c () # toConstr :: () -> Constr # dataTypeOf :: () -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ()) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ()) # gmapT :: (forall b. Data b => b -> b) -> () -> () # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> () -> r # gmapQr :: (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 Con
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Con -> c Con # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Con # toConstr :: Con -> Constr # dataTypeOf :: Con -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Con) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Con) # gmapT :: (forall b. Data b => b -> b) -> Con -> Con # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Con -> r # gmapQr :: (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 ByteString
Instance details Defined in Data.ByteString.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteString -> c ByteString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteString # toConstr :: ByteString -> Constr # dataTypeOf :: ByteString -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteString) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteString) # gmapT :: (forall b. Data b => b -> b) -> ByteString -> ByteString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQ :: (forall d. Data d => d -> u) -> ByteString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString #
Data ByteString
Instance details Defined in Data.ByteString.Lazy.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteString -> c ByteString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteString # toConstr :: ByteString -> Constr # dataTypeOf :: ByteString -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteString) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteString) # gmapT :: (forall b. Data b => b -> b) -> ByteString -> ByteString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteString -> r # gmapQ :: (forall d. Data d => d -> u) -> ByteString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteString -> m ByteString #
Data Scientific
Instance details Defined in Data.Scientific Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Scientific -> c Scientific # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Scientific # toConstr :: Scientific -> Constr # dataTypeOf :: Scientific -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Scientific) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scientific) # gmapT :: (forall b. Data b => b -> b) -> Scientific -> Scientific # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scientific -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scientific -> r # gmapQ :: (forall d. Data d => d -> u) -> Scientific -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Scientific -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Scientific -> m Scientific # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Scientific -> m Scientific # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Scientific -> m Scientific #
Data UTCTime
Instance details Defined in Data.Time.Clock.Internal.UTCTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UTCTime -> c UTCTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UTCTime # toConstr :: UTCTime -> Constr # dataTypeOf :: UTCTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c UTCTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UTCTime) # gmapT :: (forall b. Data b => b -> b) -> UTCTime -> UTCTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UTCTime -> r # gmapQ :: (forall d. Data d => d -> u) -> UTCTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> UTCTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UTCTime -> m UTCTime #
Data Value
Instance details Defined in Data.Aeson.Types.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Value -> c Value # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Value # toConstr :: Value -> Constr # dataTypeOf :: Value -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Value) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Value) # gmapT :: (forall b. Data b => b -> b) -> Value -> Value # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Value -> r # gmapQ :: (forall d. Data d => d -> u) -> Value -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Value -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Value -> m Value #
Data Number
Instance details Defined in Data.Attoparsec.Number Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Number -> c Number # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Number # toConstr :: Number -> Constr # dataTypeOf :: Number -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Number) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Number) # gmapT :: (forall b. Data b => b -> b) -> Number -> Number # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Number -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Number -> r # gmapQ :: (forall d. Data d => d -> u) -> Number -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Number -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Number -> m Number # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Number -> m Number # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Number -> m Number #
Data Void	Since: base-4.8.0.0
Instance details Defined in Data.Void Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Void -> c Void # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Void # toConstr :: Void -> Constr # dataTypeOf :: Void -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Void) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Void) # gmapT :: (forall b. Data b => b -> b) -> Void -> Void # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Void -> r # gmapQ :: (forall d. Data d => d -> u) -> Void -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Void -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Void -> m Void #
Data SpecConstrAnnotation	Since: base-4.3.0.0
Instance details Defined in GHC.Exts Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SpecConstrAnnotation -> c SpecConstrAnnotation # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SpecConstrAnnotation # toConstr :: SpecConstrAnnotation -> Constr # dataTypeOf :: SpecConstrAnnotation -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SpecConstrAnnotation) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SpecConstrAnnotation) # gmapT :: (forall b. Data b => b -> b) -> SpecConstrAnnotation -> SpecConstrAnnotation # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SpecConstrAnnotation -> r # gmapQ :: (forall d. Data d => d -> u) -> SpecConstrAnnotation -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SpecConstrAnnotation -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SpecConstrAnnotation -> m SpecConstrAnnotation #
Data Version	Since: base-4.7.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Version -> c Version # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Version # toConstr :: Version -> Constr # dataTypeOf :: Version -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Version) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Version) # gmapT :: (forall b. Data b => b -> b) -> Version -> Version # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Version -> r # gmapQ :: (forall d. Data d => d -> u) -> Version -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Version -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Version -> m Version # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Version -> m Version #
Data All	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All # toConstr :: All -> Constr # dataTypeOf :: All -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c All) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) # gmapT :: (forall b. Data b => b -> b) -> All -> All # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r # gmapQ :: (forall d. Data d => d -> u) -> All -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All #
Data Any	Since: base-4.8.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any # toConstr :: Any -> Constr # dataTypeOf :: Any -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Any) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) # gmapT :: (forall b. Data b => b -> b) -> Any -> Any # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r # gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any #
Data Fixity	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity # toConstr :: Fixity -> Constr # dataTypeOf :: Fixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #
Data Associativity	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Associativity -> c Associativity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Associativity # toConstr :: Associativity -> Constr # dataTypeOf :: Associativity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Associativity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Associativity) # gmapT :: (forall b. Data b => b -> b) -> Associativity -> Associativity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Associativity -> r # gmapQ :: (forall d. Data d => d -> u) -> Associativity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Associativity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Associativity -> m Associativity #
Data SourceUnpackedness	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceUnpackedness # toConstr :: SourceUnpackedness -> Constr # dataTypeOf :: SourceUnpackedness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceUnpackedness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceUnpackedness) # gmapT :: (forall b. Data b => b -> b) -> SourceUnpackedness -> SourceUnpackedness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceUnpackedness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceUnpackedness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceUnpackedness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceUnpackedness -> m SourceUnpackedness #
Data SourceStrictness	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SourceStrictness # toConstr :: SourceStrictness -> Constr # dataTypeOf :: SourceStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SourceStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceStrictness) # gmapT :: (forall b. Data b => b -> b) -> SourceStrictness -> SourceStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SourceStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> SourceStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SourceStrictness -> m SourceStrictness #
Data DecidedStrictness	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DecidedStrictness # toConstr :: DecidedStrictness -> Constr # dataTypeOf :: DecidedStrictness -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DecidedStrictness) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DecidedStrictness) # gmapT :: (forall b. Data b => b -> b) -> DecidedStrictness -> DecidedStrictness # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DecidedStrictness -> r # gmapQ :: (forall d. Data d => d -> u) -> DecidedStrictness -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DecidedStrictness -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DecidedStrictness -> m DecidedStrictness #
Data WordPtr	Since: base-4.11.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WordPtr -> c WordPtr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c WordPtr # toConstr :: WordPtr -> Constr # dataTypeOf :: WordPtr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c WordPtr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WordPtr) # gmapT :: (forall b. Data b => b -> b) -> WordPtr -> WordPtr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WordPtr -> r # gmapQ :: (forall d. Data d => d -> u) -> WordPtr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> WordPtr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WordPtr -> m WordPtr #
Data IntPtr	Since: base-4.11.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntPtr -> c IntPtr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntPtr # toConstr :: IntPtr -> Constr # dataTypeOf :: IntPtr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntPtr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntPtr) # gmapT :: (forall b. Data b => b -> b) -> IntPtr -> IntPtr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntPtr -> r # gmapQ :: (forall d. Data d => d -> u) -> IntPtr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IntPtr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntPtr -> m IntPtr #
Data Encoding
Instance details Defined in Basement.String Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Encoding -> c Encoding # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Encoding # toConstr :: Encoding -> Constr # dataTypeOf :: Encoding -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Encoding) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Encoding) # gmapT :: (forall b. Data b => b -> b) -> Encoding -> Encoding # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Encoding -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Encoding -> r # gmapQ :: (forall d. Data d => d -> u) -> Encoding -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Encoding -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Encoding -> m Encoding # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Encoding -> m Encoding # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Encoding -> m Encoding #
Data String
Instance details Defined in Basement.UTF8.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> String -> c String # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c String # toConstr :: String -> Constr # dataTypeOf :: String -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c String) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c String) # gmapT :: (forall b. Data b => b -> b) -> String -> String # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> String -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> String -> r # gmapQ :: (forall d. Data d => d -> u) -> String -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> String -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> String -> m String # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> String -> m String #
Data ShortByteString
Instance details Defined in Data.ByteString.Short.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ShortByteString -> c ShortByteString # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ShortByteString # toConstr :: ShortByteString -> Constr # dataTypeOf :: ShortByteString -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ShortByteString) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ShortByteString) # gmapT :: (forall b. Data b => b -> b) -> ShortByteString -> ShortByteString # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ShortByteString -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ShortByteString -> r # gmapQ :: (forall d. Data d => d -> u) -> ShortByteString -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ShortByteString -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ShortByteString -> m ShortByteString # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ShortByteString -> m ShortByteString # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ShortByteString -> m ShortByteString #
Data IntSet
Instance details Defined in Data.IntSet.Internal Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntSet -> c IntSet # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IntSet # toConstr :: IntSet -> Constr # dataTypeOf :: IntSet -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IntSet) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IntSet) # gmapT :: (forall b. Data b => b -> b) -> IntSet -> IntSet # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntSet -> r # gmapQr :: (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 DiffTime
Instance details Defined in Data.Time.Clock.Internal.DiffTime Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DiffTime -> c DiffTime # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DiffTime # toConstr :: DiffTime -> Constr # dataTypeOf :: DiffTime -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DiffTime) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DiffTime) # gmapT :: (forall b. Data b => b -> b) -> DiffTime -> DiffTime # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DiffTime -> r # gmapQ :: (forall d. Data d => d -> u) -> DiffTime -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DiffTime -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DiffTime -> m DiffTime #
Data Curve_P256R1
Instance details Defined in Crypto.ECC Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Curve_P256R1 -> c Curve_P256R1 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Curve_P256R1 # toConstr :: Curve_P256R1 -> Constr # dataTypeOf :: Curve_P256R1 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Curve_P256R1) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Curve_P256R1) # gmapT :: (forall b. Data b => b -> b) -> Curve_P256R1 -> Curve_P256R1 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Curve_P256R1 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Curve_P256R1 -> r # gmapQ :: (forall d. Data d => d -> u) -> Curve_P256R1 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Curve_P256R1 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Curve_P256R1 -> m Curve_P256R1 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_P256R1 -> m Curve_P256R1 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_P256R1 -> m Curve_P256R1 #
Data Curve_P384R1
Instance details Defined in Crypto.ECC Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Curve_P384R1 -> c Curve_P384R1 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Curve_P384R1 # toConstr :: Curve_P384R1 -> Constr # dataTypeOf :: Curve_P384R1 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Curve_P384R1) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Curve_P384R1) # gmapT :: (forall b. Data b => b -> b) -> Curve_P384R1 -> Curve_P384R1 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Curve_P384R1 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Curve_P384R1 -> r # gmapQ :: (forall d. Data d => d -> u) -> Curve_P384R1 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Curve_P384R1 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Curve_P384R1 -> m Curve_P384R1 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_P384R1 -> m Curve_P384R1 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_P384R1 -> m Curve_P384R1 #
Data Curve_P521R1
Instance details Defined in Crypto.ECC Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Curve_P521R1 -> c Curve_P521R1 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Curve_P521R1 # toConstr :: Curve_P521R1 -> Constr # dataTypeOf :: Curve_P521R1 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Curve_P521R1) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Curve_P521R1) # gmapT :: (forall b. Data b => b -> b) -> Curve_P521R1 -> Curve_P521R1 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Curve_P521R1 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Curve_P521R1 -> r # gmapQ :: (forall d. Data d => d -> u) -> Curve_P521R1 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Curve_P521R1 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Curve_P521R1 -> m Curve_P521R1 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_P521R1 -> m Curve_P521R1 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_P521R1 -> m Curve_P521R1 #
Data Curve_X25519
Instance details Defined in Crypto.ECC Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Curve_X25519 -> c Curve_X25519 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Curve_X25519 # toConstr :: Curve_X25519 -> Constr # dataTypeOf :: Curve_X25519 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Curve_X25519) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Curve_X25519) # gmapT :: (forall b. Data b => b -> b) -> Curve_X25519 -> Curve_X25519 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Curve_X25519 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Curve_X25519 -> r # gmapQ :: (forall d. Data d => d -> u) -> Curve_X25519 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Curve_X25519 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Curve_X25519 -> m Curve_X25519 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_X25519 -> m Curve_X25519 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_X25519 -> m Curve_X25519 #
Data Curve_X448
Instance details Defined in Crypto.ECC Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Curve_X448 -> c Curve_X448 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Curve_X448 # toConstr :: Curve_X448 -> Constr # dataTypeOf :: Curve_X448 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Curve_X448) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Curve_X448) # gmapT :: (forall b. Data b => b -> b) -> Curve_X448 -> Curve_X448 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Curve_X448 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Curve_X448 -> r # gmapQ :: (forall d. Data d => d -> u) -> Curve_X448 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Curve_X448 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Curve_X448 -> m Curve_X448 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_X448 -> m Curve_X448 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_X448 -> m Curve_X448 #
Data Curve_Edwards25519
Instance details Defined in Crypto.ECC Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Curve_Edwards25519 -> c Curve_Edwards25519 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Curve_Edwards25519 # toConstr :: Curve_Edwards25519 -> Constr # dataTypeOf :: Curve_Edwards25519 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Curve_Edwards25519) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Curve_Edwards25519) # gmapT :: (forall b. Data b => b -> b) -> Curve_Edwards25519 -> Curve_Edwards25519 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Curve_Edwards25519 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Curve_Edwards25519 -> r # gmapQ :: (forall d. Data d => d -> u) -> Curve_Edwards25519 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Curve_Edwards25519 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Curve_Edwards25519 -> m Curve_Edwards25519 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_Edwards25519 -> m Curve_Edwards25519 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Curve_Edwards25519 -> m Curve_Edwards25519 #
Data CryptoError
Instance details Defined in Crypto.Error.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CryptoError -> c CryptoError # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CryptoError # toConstr :: CryptoError -> Constr # dataTypeOf :: CryptoError -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c CryptoError) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CryptoError) # gmapT :: (forall b. Data b => b -> b) -> CryptoError -> CryptoError # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CryptoError -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CryptoError -> r # gmapQ :: (forall d. Data d => d -> u) -> CryptoError -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> CryptoError -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> CryptoError -> m CryptoError # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CryptoError -> m CryptoError # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CryptoError -> m CryptoError #
Data Blake2b_160
Instance details Defined in Crypto.Hash.Blake2b Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_160 -> c Blake2b_160 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_160 # toConstr :: Blake2b_160 -> Constr # dataTypeOf :: Blake2b_160 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_160) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_160) # gmapT :: (forall b. Data b => b -> b) -> Blake2b_160 -> Blake2b_160 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_160 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_160 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2b_160 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_160 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_160 -> m Blake2b_160 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_160 -> m Blake2b_160 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_160 -> m Blake2b_160 #
Data Blake2b_224
Instance details Defined in Crypto.Hash.Blake2b Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_224 -> c Blake2b_224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_224 # toConstr :: Blake2b_224 -> Constr # dataTypeOf :: Blake2b_224 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_224) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_224) # gmapT :: (forall b. Data b => b -> b) -> Blake2b_224 -> Blake2b_224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_224 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2b_224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_224 -> m Blake2b_224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_224 -> m Blake2b_224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_224 -> m Blake2b_224 #
Data Blake2b_256
Instance details Defined in Crypto.Hash.Blake2b Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_256 -> c Blake2b_256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_256 # toConstr :: Blake2b_256 -> Constr # dataTypeOf :: Blake2b_256 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_256) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_256) # gmapT :: (forall b. Data b => b -> b) -> Blake2b_256 -> Blake2b_256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_256 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2b_256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_256 -> m Blake2b_256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_256 -> m Blake2b_256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_256 -> m Blake2b_256 #
Data Blake2b_384
Instance details Defined in Crypto.Hash.Blake2b Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_384 -> c Blake2b_384 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_384 # toConstr :: Blake2b_384 -> Constr # dataTypeOf :: Blake2b_384 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_384) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_384) # gmapT :: (forall b. Data b => b -> b) -> Blake2b_384 -> Blake2b_384 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_384 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_384 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2b_384 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_384 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_384 -> m Blake2b_384 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_384 -> m Blake2b_384 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_384 -> m Blake2b_384 #
Data Blake2b_512
Instance details Defined in Crypto.Hash.Blake2b Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2b_512 -> c Blake2b_512 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2b_512 # toConstr :: Blake2b_512 -> Constr # dataTypeOf :: Blake2b_512 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2b_512) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2b_512) # gmapT :: (forall b. Data b => b -> b) -> Blake2b_512 -> Blake2b_512 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_512 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2b_512 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2b_512 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2b_512 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2b_512 -> m Blake2b_512 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_512 -> m Blake2b_512 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2b_512 -> m Blake2b_512 #
Data Blake2bp_512
Instance details Defined in Crypto.Hash.Blake2bp Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2bp_512 -> c Blake2bp_512 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2bp_512 # toConstr :: Blake2bp_512 -> Constr # dataTypeOf :: Blake2bp_512 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2bp_512) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2bp_512) # gmapT :: (forall b. Data b => b -> b) -> Blake2bp_512 -> Blake2bp_512 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2bp_512 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2bp_512 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2bp_512 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2bp_512 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2bp_512 -> m Blake2bp_512 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2bp_512 -> m Blake2bp_512 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2bp_512 -> m Blake2bp_512 #
Data Blake2s_160
Instance details Defined in Crypto.Hash.Blake2s Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2s_160 -> c Blake2s_160 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2s_160 # toConstr :: Blake2s_160 -> Constr # dataTypeOf :: Blake2s_160 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2s_160) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2s_160) # gmapT :: (forall b. Data b => b -> b) -> Blake2s_160 -> Blake2s_160 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_160 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_160 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2s_160 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2s_160 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2s_160 -> m Blake2s_160 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_160 -> m Blake2s_160 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_160 -> m Blake2s_160 #
Data Blake2s_224
Instance details Defined in Crypto.Hash.Blake2s Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2s_224 -> c Blake2s_224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2s_224 # toConstr :: Blake2s_224 -> Constr # dataTypeOf :: Blake2s_224 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2s_224) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2s_224) # gmapT :: (forall b. Data b => b -> b) -> Blake2s_224 -> Blake2s_224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_224 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2s_224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2s_224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2s_224 -> m Blake2s_224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_224 -> m Blake2s_224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_224 -> m Blake2s_224 #
Data Blake2s_256
Instance details Defined in Crypto.Hash.Blake2s Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2s_256 -> c Blake2s_256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2s_256 # toConstr :: Blake2s_256 -> Constr # dataTypeOf :: Blake2s_256 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2s_256) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2s_256) # gmapT :: (forall b. Data b => b -> b) -> Blake2s_256 -> Blake2s_256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2s_256 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2s_256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2s_256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2s_256 -> m Blake2s_256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_256 -> m Blake2s_256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2s_256 -> m Blake2s_256 #
Data Blake2sp_224
Instance details Defined in Crypto.Hash.Blake2sp Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2sp_224 -> c Blake2sp_224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2sp_224 # toConstr :: Blake2sp_224 -> Constr # dataTypeOf :: Blake2sp_224 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2sp_224) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2sp_224) # gmapT :: (forall b. Data b => b -> b) -> Blake2sp_224 -> Blake2sp_224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2sp_224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2sp_224 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2sp_224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2sp_224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2sp_224 -> m Blake2sp_224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2sp_224 -> m Blake2sp_224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2sp_224 -> m Blake2sp_224 #
Data Blake2sp_256
Instance details Defined in Crypto.Hash.Blake2sp Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Blake2sp_256 -> c Blake2sp_256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Blake2sp_256 # toConstr :: Blake2sp_256 -> Constr # dataTypeOf :: Blake2sp_256 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Blake2sp_256) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Blake2sp_256) # gmapT :: (forall b. Data b => b -> b) -> Blake2sp_256 -> Blake2sp_256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Blake2sp_256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Blake2sp_256 -> r # gmapQ :: (forall d. Data d => d -> u) -> Blake2sp_256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Blake2sp_256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Blake2sp_256 -> m Blake2sp_256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2sp_256 -> m Blake2sp_256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Blake2sp_256 -> m Blake2sp_256 #
Data Keccak_224
Instance details Defined in Crypto.Hash.Keccak Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Keccak_224 -> c Keccak_224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Keccak_224 # toConstr :: Keccak_224 -> Constr # dataTypeOf :: Keccak_224 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Keccak_224) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keccak_224) # gmapT :: (forall b. Data b => b -> b) -> Keccak_224 -> Keccak_224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_224 -> r # gmapQ :: (forall d. Data d => d -> u) -> Keccak_224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Keccak_224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Keccak_224 -> m Keccak_224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_224 -> m Keccak_224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_224 -> m Keccak_224 #
Data Keccak_256
Instance details Defined in Crypto.Hash.Keccak Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Keccak_256 -> c Keccak_256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Keccak_256 # toConstr :: Keccak_256 -> Constr # dataTypeOf :: Keccak_256 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Keccak_256) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keccak_256) # gmapT :: (forall b. Data b => b -> b) -> Keccak_256 -> Keccak_256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_256 -> r # gmapQ :: (forall d. Data d => d -> u) -> Keccak_256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Keccak_256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Keccak_256 -> m Keccak_256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_256 -> m Keccak_256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_256 -> m Keccak_256 #
Data Keccak_384
Instance details Defined in Crypto.Hash.Keccak Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Keccak_384 -> c Keccak_384 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Keccak_384 # toConstr :: Keccak_384 -> Constr # dataTypeOf :: Keccak_384 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Keccak_384) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keccak_384) # gmapT :: (forall b. Data b => b -> b) -> Keccak_384 -> Keccak_384 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_384 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_384 -> r # gmapQ :: (forall d. Data d => d -> u) -> Keccak_384 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Keccak_384 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Keccak_384 -> m Keccak_384 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_384 -> m Keccak_384 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_384 -> m Keccak_384 #
Data Keccak_512
Instance details Defined in Crypto.Hash.Keccak Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Keccak_512 -> c Keccak_512 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Keccak_512 # toConstr :: Keccak_512 -> Constr # dataTypeOf :: Keccak_512 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Keccak_512) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Keccak_512) # gmapT :: (forall b. Data b => b -> b) -> Keccak_512 -> Keccak_512 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_512 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Keccak_512 -> r # gmapQ :: (forall d. Data d => d -> u) -> Keccak_512 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Keccak_512 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Keccak_512 -> m Keccak_512 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_512 -> m Keccak_512 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Keccak_512 -> m Keccak_512 #
Data MD2
Instance details Defined in Crypto.Hash.MD2 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MD2 -> c MD2 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MD2 # toConstr :: MD2 -> Constr # dataTypeOf :: MD2 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MD2) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MD2) # gmapT :: (forall b. Data b => b -> b) -> MD2 -> MD2 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MD2 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MD2 -> r # gmapQ :: (forall d. Data d => d -> u) -> MD2 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> MD2 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> MD2 -> m MD2 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MD2 -> m MD2 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MD2 -> m MD2 #
Data MD4
Instance details Defined in Crypto.Hash.MD4 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MD4 -> c MD4 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MD4 # toConstr :: MD4 -> Constr # dataTypeOf :: MD4 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MD4) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MD4) # gmapT :: (forall b. Data b => b -> b) -> MD4 -> MD4 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MD4 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MD4 -> r # gmapQ :: (forall d. Data d => d -> u) -> MD4 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> MD4 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> MD4 -> m MD4 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MD4 -> m MD4 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MD4 -> m MD4 #
Data MD5
Instance details Defined in Crypto.Hash.MD5 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MD5 -> c MD5 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MD5 # toConstr :: MD5 -> Constr # dataTypeOf :: MD5 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c MD5) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MD5) # gmapT :: (forall b. Data b => b -> b) -> MD5 -> MD5 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MD5 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MD5 -> r # gmapQ :: (forall d. Data d => d -> u) -> MD5 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> MD5 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> MD5 -> m MD5 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MD5 -> m MD5 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MD5 -> m MD5 #
Data RIPEMD160
Instance details Defined in Crypto.Hash.RIPEMD160 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RIPEMD160 -> c RIPEMD160 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RIPEMD160 # toConstr :: RIPEMD160 -> Constr # dataTypeOf :: RIPEMD160 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RIPEMD160) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RIPEMD160) # gmapT :: (forall b. Data b => b -> b) -> RIPEMD160 -> RIPEMD160 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RIPEMD160 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RIPEMD160 -> r # gmapQ :: (forall d. Data d => d -> u) -> RIPEMD160 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RIPEMD160 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RIPEMD160 -> m RIPEMD160 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RIPEMD160 -> m RIPEMD160 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RIPEMD160 -> m RIPEMD160 #
Data SHA1
Instance details Defined in Crypto.Hash.SHA1 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA1 -> c SHA1 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA1 # toConstr :: SHA1 -> Constr # dataTypeOf :: SHA1 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA1) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA1) # gmapT :: (forall b. Data b => b -> b) -> SHA1 -> SHA1 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA1 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA1 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA1 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA1 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA1 -> m SHA1 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA1 -> m SHA1 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA1 -> m SHA1 #
Data SHA224
Instance details Defined in Crypto.Hash.SHA224 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA224 -> c SHA224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA224 # toConstr :: SHA224 -> Constr # dataTypeOf :: SHA224 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA224) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA224) # gmapT :: (forall b. Data b => b -> b) -> SHA224 -> SHA224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA224 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA224 -> m SHA224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA224 -> m SHA224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA224 -> m SHA224 #
Data SHA256
Instance details Defined in Crypto.Hash.SHA256 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA256 -> c SHA256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA256 # toConstr :: SHA256 -> Constr # dataTypeOf :: SHA256 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA256) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA256) # gmapT :: (forall b. Data b => b -> b) -> SHA256 -> SHA256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA256 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA256 -> m SHA256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA256 -> m SHA256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA256 -> m SHA256 #
Data SHA3_224
Instance details Defined in Crypto.Hash.SHA3 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA3_224 -> c SHA3_224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA3_224 # toConstr :: SHA3_224 -> Constr # dataTypeOf :: SHA3_224 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA3_224) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA3_224) # gmapT :: (forall b. Data b => b -> b) -> SHA3_224 -> SHA3_224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_224 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA3_224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA3_224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA3_224 -> m SHA3_224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_224 -> m SHA3_224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_224 -> m SHA3_224 #
Data SHA3_256
Instance details Defined in Crypto.Hash.SHA3 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA3_256 -> c SHA3_256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA3_256 # toConstr :: SHA3_256 -> Constr # dataTypeOf :: SHA3_256 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA3_256) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA3_256) # gmapT :: (forall b. Data b => b -> b) -> SHA3_256 -> SHA3_256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_256 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA3_256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA3_256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA3_256 -> m SHA3_256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_256 -> m SHA3_256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_256 -> m SHA3_256 #
Data SHA3_384
Instance details Defined in Crypto.Hash.SHA3 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA3_384 -> c SHA3_384 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA3_384 # toConstr :: SHA3_384 -> Constr # dataTypeOf :: SHA3_384 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA3_384) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA3_384) # gmapT :: (forall b. Data b => b -> b) -> SHA3_384 -> SHA3_384 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_384 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_384 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA3_384 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA3_384 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA3_384 -> m SHA3_384 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_384 -> m SHA3_384 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_384 -> m SHA3_384 #
Data SHA3_512
Instance details Defined in Crypto.Hash.SHA3 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA3_512 -> c SHA3_512 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA3_512 # toConstr :: SHA3_512 -> Constr # dataTypeOf :: SHA3_512 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA3_512) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA3_512) # gmapT :: (forall b. Data b => b -> b) -> SHA3_512 -> SHA3_512 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_512 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA3_512 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA3_512 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA3_512 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA3_512 -> m SHA3_512 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_512 -> m SHA3_512 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA3_512 -> m SHA3_512 #
Data SHA384
Instance details Defined in Crypto.Hash.SHA384 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA384 -> c SHA384 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA384 # toConstr :: SHA384 -> Constr # dataTypeOf :: SHA384 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA384) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA384) # gmapT :: (forall b. Data b => b -> b) -> SHA384 -> SHA384 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA384 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA384 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA384 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA384 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA384 -> m SHA384 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA384 -> m SHA384 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA384 -> m SHA384 #
Data SHA512
Instance details Defined in Crypto.Hash.SHA512 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA512 -> c SHA512 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA512 # toConstr :: SHA512 -> Constr # dataTypeOf :: SHA512 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA512) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA512) # gmapT :: (forall b. Data b => b -> b) -> SHA512 -> SHA512 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA512 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA512 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA512 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA512 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA512 -> m SHA512 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512 -> m SHA512 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512 -> m SHA512 #
Data SHA512t_224
Instance details Defined in Crypto.Hash.SHA512t Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA512t_224 -> c SHA512t_224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA512t_224 # toConstr :: SHA512t_224 -> Constr # dataTypeOf :: SHA512t_224 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA512t_224) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA512t_224) # gmapT :: (forall b. Data b => b -> b) -> SHA512t_224 -> SHA512t_224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA512t_224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA512t_224 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA512t_224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA512t_224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA512t_224 -> m SHA512t_224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512t_224 -> m SHA512t_224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512t_224 -> m SHA512t_224 #
Data SHA512t_256
Instance details Defined in Crypto.Hash.SHA512t Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SHA512t_256 -> c SHA512t_256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SHA512t_256 # toConstr :: SHA512t_256 -> Constr # dataTypeOf :: SHA512t_256 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c SHA512t_256) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SHA512t_256) # gmapT :: (forall b. Data b => b -> b) -> SHA512t_256 -> SHA512t_256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SHA512t_256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SHA512t_256 -> r # gmapQ :: (forall d. Data d => d -> u) -> SHA512t_256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> SHA512t_256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> SHA512t_256 -> m SHA512t_256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512t_256 -> m SHA512t_256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SHA512t_256 -> m SHA512t_256 #
Data Skein256_224
Instance details Defined in Crypto.Hash.Skein256 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein256_224 -> c Skein256_224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein256_224 # toConstr :: Skein256_224 -> Constr # dataTypeOf :: Skein256_224 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Skein256_224) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein256_224) # gmapT :: (forall b. Data b => b -> b) -> Skein256_224 -> Skein256_224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein256_224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein256_224 -> r # gmapQ :: (forall d. Data d => d -> u) -> Skein256_224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein256_224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein256_224 -> m Skein256_224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein256_224 -> m Skein256_224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein256_224 -> m Skein256_224 #
Data Skein256_256
Instance details Defined in Crypto.Hash.Skein256 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein256_256 -> c Skein256_256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein256_256 # toConstr :: Skein256_256 -> Constr # dataTypeOf :: Skein256_256 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Skein256_256) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein256_256) # gmapT :: (forall b. Data b => b -> b) -> Skein256_256 -> Skein256_256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein256_256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein256_256 -> r # gmapQ :: (forall d. Data d => d -> u) -> Skein256_256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein256_256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein256_256 -> m Skein256_256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein256_256 -> m Skein256_256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein256_256 -> m Skein256_256 #
Data Skein512_224
Instance details Defined in Crypto.Hash.Skein512 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein512_224 -> c Skein512_224 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein512_224 # toConstr :: Skein512_224 -> Constr # dataTypeOf :: Skein512_224 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Skein512_224) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein512_224) # gmapT :: (forall b. Data b => b -> b) -> Skein512_224 -> Skein512_224 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_224 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_224 -> r # gmapQ :: (forall d. Data d => d -> u) -> Skein512_224 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein512_224 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein512_224 -> m Skein512_224 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_224 -> m Skein512_224 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_224 -> m Skein512_224 #
Data Skein512_256
Instance details Defined in Crypto.Hash.Skein512 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein512_256 -> c Skein512_256 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein512_256 # toConstr :: Skein512_256 -> Constr # dataTypeOf :: Skein512_256 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Skein512_256) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein512_256) # gmapT :: (forall b. Data b => b -> b) -> Skein512_256 -> Skein512_256 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_256 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_256 -> r # gmapQ :: (forall d. Data d => d -> u) -> Skein512_256 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein512_256 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein512_256 -> m Skein512_256 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_256 -> m Skein512_256 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_256 -> m Skein512_256 #
Data Skein512_384
Instance details Defined in Crypto.Hash.Skein512 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein512_384 -> c Skein512_384 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein512_384 # toConstr :: Skein512_384 -> Constr # dataTypeOf :: Skein512_384 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Skein512_384) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein512_384) # gmapT :: (forall b. Data b => b -> b) -> Skein512_384 -> Skein512_384 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_384 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_384 -> r # gmapQ :: (forall d. Data d => d -> u) -> Skein512_384 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein512_384 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein512_384 -> m Skein512_384 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_384 -> m Skein512_384 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_384 -> m Skein512_384 #
Data Skein512_512
Instance details Defined in Crypto.Hash.Skein512 Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Skein512_512 -> c Skein512_512 # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Skein512_512 # toConstr :: Skein512_512 -> Constr # dataTypeOf :: Skein512_512 -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Skein512_512) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Skein512_512) # gmapT :: (forall b. Data b => b -> b) -> Skein512_512 -> Skein512_512 # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_512 -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Skein512_512 -> r # gmapQ :: (forall d. Data d => d -> u) -> Skein512_512 -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Skein512_512 -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Skein512_512 -> m Skein512_512 # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_512 -> m Skein512_512 # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Skein512_512 -> m Skein512_512 #
Data Tiger
Instance details Defined in Crypto.Hash.Tiger Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tiger -> c Tiger # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tiger # toConstr :: Tiger -> Constr # dataTypeOf :: Tiger -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Tiger) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tiger) # gmapT :: (forall b. Data b => b -> b) -> Tiger -> Tiger # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tiger -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tiger -> r # gmapQ :: (forall d. Data d => d -> u) -> Tiger -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Tiger -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tiger -> m Tiger # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tiger -> m Tiger # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tiger -> m Tiger #
Data Whirlpool
Instance details Defined in Crypto.Hash.Whirlpool Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Whirlpool -> c Whirlpool # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Whirlpool # toConstr :: Whirlpool -> Constr # dataTypeOf :: Whirlpool -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Whirlpool) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Whirlpool) # gmapT :: (forall b. Data b => b -> b) -> Whirlpool -> Whirlpool # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Whirlpool -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Whirlpool -> r # gmapQ :: (forall d. Data d => d -> u) -> Whirlpool -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Whirlpool -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Whirlpool -> m Whirlpool # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Whirlpool -> m Whirlpool # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Whirlpool -> m Whirlpool #
Data URI
Instance details Defined in Network.URI Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URI -> c URI # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c URI # toConstr :: URI -> Constr # dataTypeOf :: URI -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c URI) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URI) # gmapT :: (forall b. Data b => b -> b) -> URI -> URI # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URI -> r # gmapQr :: (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 ByteRange
Instance details Defined in Network.HTTP.Types.Header Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteRange -> c ByteRange # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteRange # toConstr :: ByteRange -> Constr # dataTypeOf :: ByteRange -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteRange) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteRange) # gmapT :: (forall b. Data b => b -> b) -> ByteRange -> ByteRange # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteRange -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteRange -> r # gmapQ :: (forall d. Data d => d -> u) -> ByteRange -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteRange -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteRange -> m ByteRange # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteRange -> m ByteRange # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteRange -> m ByteRange #
Data TyVarBndr
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyVarBndr -> c TyVarBndr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyVarBndr # toConstr :: TyVarBndr -> Constr # dataTypeOf :: TyVarBndr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyVarBndr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVarBndr) # gmapT :: (forall b. Data b => b -> b) -> TyVarBndr -> TyVarBndr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVarBndr -> r # gmapQr :: (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 URIAuth
Instance details Defined in Network.URI Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URIAuth -> c URIAuth # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c URIAuth # toConstr :: URIAuth -> Constr # dataTypeOf :: URIAuth -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c URIAuth) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URIAuth) # gmapT :: (forall b. Data b => b -> b) -> URIAuth -> URIAuth # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URIAuth -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URIAuth -> r # gmapQ :: (forall d. Data d => d -> u) -> URIAuth -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> URIAuth -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> URIAuth -> m URIAuth # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URIAuth -> m URIAuth # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URIAuth -> m URIAuth #
Data ByteArray
Instance details Defined in Data.Primitive.ByteArray Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ByteArray -> c ByteArray # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ByteArray # toConstr :: ByteArray -> Constr # dataTypeOf :: ByteArray -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ByteArray) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteArray) # gmapT :: (forall b. Data b => b -> b) -> ByteArray -> ByteArray # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ByteArray -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ByteArray -> r # gmapQ :: (forall d. Data d => d -> u) -> ByteArray -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ByteArray -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ByteArray -> m ByteArray # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteArray -> m ByteArray # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ByteArray -> m ByteArray #
Data Addr
Instance details Defined in Data.Primitive.Types Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Addr -> c Addr # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Addr # toConstr :: Addr -> Constr # dataTypeOf :: Addr -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Addr) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Addr) # gmapT :: (forall b. Data b => b -> b) -> Addr -> Addr # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Addr -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Addr -> r # gmapQ :: (forall d. Data d => d -> u) -> Addr -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Addr -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Addr -> m Addr # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Addr -> m Addr # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Addr -> m Addr #
Data ModName
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModName -> c ModName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModName # toConstr :: ModName -> Constr # dataTypeOf :: ModName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModName) # gmapT :: (forall b. Data b => b -> b) -> ModName -> ModName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModName -> r # gmapQ :: (forall d. Data d => d -> u) -> ModName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModName -> m ModName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModName -> m ModName #
Data PkgName
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PkgName -> c PkgName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PkgName # toConstr :: PkgName -> Constr # dataTypeOf :: PkgName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PkgName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PkgName) # gmapT :: (forall b. Data b => b -> b) -> PkgName -> PkgName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PkgName -> r # gmapQ :: (forall d. Data d => d -> u) -> PkgName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> PkgName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PkgName -> m PkgName #
Data Module
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module # toConstr :: Module -> Constr # dataTypeOf :: Module -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Module) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) # gmapT :: (forall b. Data b => b -> b) -> Module -> Module # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r # gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module #
Data OccName
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OccName -> c OccName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OccName # toConstr :: OccName -> Constr # dataTypeOf :: OccName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OccName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OccName) # gmapT :: (forall b. Data b => b -> b) -> OccName -> OccName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OccName -> r # gmapQ :: (forall d. Data d => d -> u) -> OccName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OccName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OccName -> m OccName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OccName -> m OccName #
Data NameFlavour
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameFlavour -> c NameFlavour # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameFlavour # toConstr :: NameFlavour -> Constr # dataTypeOf :: NameFlavour -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameFlavour) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameFlavour) # gmapT :: (forall b. Data b => b -> b) -> NameFlavour -> NameFlavour # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameFlavour -> r # gmapQ :: (forall d. Data d => d -> u) -> NameFlavour -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameFlavour -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameFlavour -> m NameFlavour #
Data NameSpace
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NameSpace -> c NameSpace # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c NameSpace # toConstr :: NameSpace -> Constr # dataTypeOf :: NameSpace -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c NameSpace) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameSpace) # gmapT :: (forall b. Data b => b -> b) -> NameSpace -> NameSpace # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NameSpace -> r # gmapQ :: (forall d. Data d => d -> u) -> NameSpace -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> NameSpace -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NameSpace -> m NameSpace #
Data Loc
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Loc -> c Loc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Loc # toConstr :: Loc -> Constr # dataTypeOf :: Loc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Loc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Loc) # gmapT :: (forall b. Data b => b -> b) -> Loc -> Loc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Loc -> r # gmapQ :: (forall d. Data d => d -> u) -> Loc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Loc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Loc -> m Loc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Loc -> m Loc #
Data Info
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Info -> c Info # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Info # toConstr :: Info -> Constr # dataTypeOf :: Info -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Info) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Info) # gmapT :: (forall b. Data b => b -> b) -> Info -> Info # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Info -> r # gmapQ :: (forall d. Data d => d -> u) -> Info -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Info -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Info -> m Info # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Info -> m Info #
Data ModuleInfo
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleInfo -> c ModuleInfo # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleInfo # toConstr :: ModuleInfo -> Constr # dataTypeOf :: ModuleInfo -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ModuleInfo) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleInfo) # gmapT :: (forall b. Data b => b -> b) -> ModuleInfo -> ModuleInfo # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleInfo -> r # gmapQ :: (forall d. Data d => d -> u) -> ModuleInfo -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleInfo -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleInfo -> m ModuleInfo #
Data Fixity
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Fixity # toConstr :: Fixity -> Constr # dataTypeOf :: Fixity -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Fixity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Fixity) # gmapT :: (forall b. Data b => b -> b) -> Fixity -> Fixity # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixity -> r # gmapQ :: (forall d. Data d => d -> u) -> Fixity -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixity -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixity -> m Fixity #
Data FixityDirection
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FixityDirection -> c FixityDirection # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FixityDirection # toConstr :: FixityDirection -> Constr # dataTypeOf :: FixityDirection -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FixityDirection) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FixityDirection) # gmapT :: (forall b. Data b => b -> b) -> FixityDirection -> FixityDirection # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FixityDirection -> r # gmapQ :: (forall d. Data d => d -> u) -> FixityDirection -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FixityDirection -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FixityDirection -> m FixityDirection #
Data Lit
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Lit -> c Lit # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Lit # toConstr :: Lit -> Constr # dataTypeOf :: Lit -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Lit) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Lit) # gmapT :: (forall b. Data b => b -> b) -> Lit -> Lit # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Lit -> r # gmapQr :: (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
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Body -> c Body # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Body # toConstr :: Body -> Constr # dataTypeOf :: Body -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Body) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Body) # gmapT :: (forall b. Data b => b -> b) -> Body -> Body # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Body -> r # gmapQ :: (forall d. Data d => d -> u) -> Body -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Body -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Body -> m Body # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Body -> m Body #
Data Guard
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Guard -> c Guard # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Guard # toConstr :: Guard -> Constr # dataTypeOf :: Guard -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Guard) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Guard) # gmapT :: (forall b. Data b => b -> b) -> Guard -> Guard # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Guard -> r # gmapQ :: (forall d. Data d => d -> u) -> Guard -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Guard -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Guard -> m Guard # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Guard -> m Guard #
Data Stmt
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Stmt -> c Stmt # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Stmt # toConstr :: Stmt -> Constr # dataTypeOf :: Stmt -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Stmt) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Stmt) # gmapT :: (forall b. Data b => b -> b) -> Stmt -> Stmt # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Stmt -> r # gmapQ :: (forall d. Data d => d -> u) -> Stmt -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Stmt -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Stmt -> m Stmt #
Data Range
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Range -> c Range # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Range # toConstr :: Range -> Constr # dataTypeOf :: Range -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Range) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Range) # gmapT :: (forall b. Data b => b -> b) -> Range -> Range # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Range -> r # gmapQ :: (forall d. Data d => d -> u) -> Range -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Range -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Range -> m Range # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Range -> m Range #
Data DerivClause
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivClause -> c DerivClause # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivClause # toConstr :: DerivClause -> Constr # dataTypeOf :: DerivClause -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivClause) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivClause) # gmapT :: (forall b. Data b => b -> b) -> DerivClause -> DerivClause # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivClause -> r # gmapQ :: (forall d. Data d => d -> u) -> DerivClause -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivClause -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivClause -> m DerivClause #
Data DerivStrategy
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DerivStrategy -> c DerivStrategy # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DerivStrategy # toConstr :: DerivStrategy -> Constr # dataTypeOf :: DerivStrategy -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c DerivStrategy) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DerivStrategy) # gmapT :: (forall b. Data b => b -> b) -> DerivStrategy -> DerivStrategy # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DerivStrategy -> r # gmapQ :: (forall d. Data d => d -> u) -> DerivStrategy -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> DerivStrategy -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DerivStrategy -> m DerivStrategy #
Data TypeFamilyHead
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TypeFamilyHead -> c TypeFamilyHead # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TypeFamilyHead # toConstr :: TypeFamilyHead -> Constr # dataTypeOf :: TypeFamilyHead -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TypeFamilyHead) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeFamilyHead) # gmapT :: (forall b. Data b => b -> b) -> TypeFamilyHead -> TypeFamilyHead # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TypeFamilyHead -> r # gmapQ :: (forall d. Data d => d -> u) -> TypeFamilyHead -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeFamilyHead -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TypeFamilyHead -> m TypeFamilyHead #
Data TySynEqn
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TySynEqn -> c TySynEqn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TySynEqn # toConstr :: TySynEqn -> Constr # dataTypeOf :: TySynEqn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TySynEqn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TySynEqn) # gmapT :: (forall b. Data b => b -> b) -> TySynEqn -> TySynEqn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TySynEqn -> r # gmapQ :: (forall d. Data d => d -> u) -> TySynEqn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> TySynEqn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TySynEqn -> m TySynEqn #
Data Foreign
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Foreign -> c Foreign # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Foreign # toConstr :: Foreign -> Constr # dataTypeOf :: Foreign -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Foreign) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Foreign) # gmapT :: (forall b. Data b => b -> b) -> Foreign -> Foreign # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Foreign -> r # gmapQ :: (forall d. Data d => d -> u) -> Foreign -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Foreign -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Foreign -> m Foreign #
Data Callconv
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Callconv -> c Callconv # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Callconv # toConstr :: Callconv -> Constr # dataTypeOf :: Callconv -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Callconv) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Callconv) # gmapT :: (forall b. Data b => b -> b) -> Callconv -> Callconv # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Callconv -> r # gmapQ :: (forall d. Data d => d -> u) -> Callconv -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Callconv -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Callconv -> m Callconv #
Data Safety
Instance details Defined in Language.Haskell.TH.Syntax Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Safety -> c Safety # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Safety # toConstr :: Safety -> Constr # dataTypeOf :: Safety -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Safety) # dataCast2 :: Typeable t => (forall d e. (Data d,