Cabal-2.0.1.0: A framework for packaging Haskell software

Safe HaskellNone
LanguageHaskell2010

Distribution.Compat.Prelude.Internal

Contents

Description

Warning: This modules' API is not stable. Use at your own risk, or better yet, use base-compat!

This module re-exports the non-exposed Distribution.Compat.Prelude module for reuse by cabal-install's Distribution.Client.Compat.Prelude module.

It is highly discouraged to rely on this module for Setup.hs scripts since its API is not stable.

Synopsis

Prelude

Common type-classes

class Semigroup a where Source #

The class of semigroups (types with an associative binary operation).

Since: 4.9.0.0

Methods

(<>) :: a -> a -> a infixr 6 Source #

An associative operation.

(a <> b) <> c = a <> (b <> c)

If a is also a Monoid we further require

(<>) = mappend

Instances

Semigroup Ordering

Since: 4.9.0.0

Semigroup ()

Since: 4.9.0.0

Methods

(<>) :: () -> () -> () Source #

sconcat :: NonEmpty () -> () Source #

stimes :: Integral b => b -> () -> () Source #

Semigroup Void

Since: 4.9.0.0

Semigroup Event

Since: 4.10.0.0

Semigroup Lifetime

Since: 4.10.0.0

Semigroup All

Since: 4.9.0.0

Methods

(<>) :: All -> All -> All Source #

sconcat :: NonEmpty All -> All Source #

stimes :: Integral b => b -> All -> All Source #

Semigroup Any

Since: 4.9.0.0

Methods

(<>) :: Any -> Any -> Any Source #

sconcat :: NonEmpty Any -> Any Source #

stimes :: Integral b => b -> Any -> Any Source #

Semigroup Builder 
Semigroup ByteString 
Semigroup ShortByteString 
Semigroup ByteString 
Semigroup IntSet 
Semigroup Doc 

Methods

(<>) :: Doc -> Doc -> Doc Source #

sconcat :: NonEmpty Doc -> Doc Source #

stimes :: Integral b => b -> Doc -> Doc Source #

Semigroup CDialect # 
Semigroup ExecutableScope # 
Semigroup ForeignLibType # 
Semigroup ShortText # 
Semigroup TestSuiteInterface # 
Semigroup BenchmarkInterface # 
Semigroup UnqualComponentName # 
Semigroup SetupBuildInfo # 
Semigroup DependencyMap # 
Semigroup BuildInfo # 
Semigroup TestSuite # 
Semigroup Library # 
Semigroup ForeignLib # 
Semigroup Executable # 
Semigroup Benchmark # 
Semigroup Component # 
Semigroup BenchmarkFlags # 
Semigroup TestFlags # 
Semigroup TestShowDetails # 
Semigroup ReplFlags # 
Semigroup BuildFlags # 
Semigroup CleanFlags # 
Semigroup HaddockFlags # 
Semigroup DoctestFlags # 
Semigroup HscolourFlags # 
Semigroup RegisterFlags # 
Semigroup SDistFlags # 
Semigroup InstallFlags # 
Semigroup CopyFlags # 
Semigroup ConfigFlags # 
Semigroup AllowOlder # 
Semigroup AllowNewer # 
Semigroup RelaxDeps # 
Semigroup GlobalFlags # 
Semigroup GhcOptions # 
Semigroup [a]

Since: 4.9.0.0

Methods

(<>) :: [a] -> [a] -> [a] Source #

sconcat :: NonEmpty [a] -> [a] Source #

stimes :: Integral b => b -> [a] -> [a] Source #

Semigroup a => Semigroup (Maybe a)

Since: 4.9.0.0

Methods

(<>) :: Maybe a -> Maybe a -> Maybe a Source #

sconcat :: NonEmpty (Maybe a) -> Maybe a Source #

stimes :: Integral b => b -> Maybe a -> Maybe a Source #

Semigroup a => Semigroup (IO a)

Since: 4.10.0.0

Methods

(<>) :: IO a -> IO a -> IO a Source #

sconcat :: NonEmpty (IO a) -> IO a Source #

stimes :: Integral b => b -> IO a -> IO a Source #

Ord a => Semigroup (Min a)

Since: 4.9.0.0

Methods

(<>) :: Min a -> Min a -> Min a Source #

sconcat :: NonEmpty (Min a) -> Min a Source #

stimes :: Integral b => b -> Min a -> Min a Source #

Ord a => Semigroup (Max a)

Since: 4.9.0.0

Methods

(<>) :: Max a -> Max a -> Max a Source #

sconcat :: NonEmpty (Max a) -> Max a Source #

stimes :: Integral b => b -> Max a -> Max a Source #

Semigroup (First a)

Since: 4.9.0.0

Methods

(<>) :: First a -> First a -> First a Source #

sconcat :: NonEmpty (First a) -> First a Source #

stimes :: Integral b => b -> First a -> First a Source #

Semigroup (Last a)

Since: 4.9.0.0

Methods

(<>) :: Last a -> Last a -> Last a Source #

sconcat :: NonEmpty (Last a) -> Last a Source #

stimes :: Integral b => b -> Last a -> Last a Source #

Monoid m => Semigroup (WrappedMonoid m)

Since: 4.9.0.0

Semigroup a => Semigroup (Option a)

Since: 4.9.0.0

Methods

(<>) :: Option a -> Option a -> Option a Source #

sconcat :: NonEmpty (Option a) -> Option a Source #

stimes :: Integral b => b -> Option a -> Option a Source #

Semigroup (NonEmpty a)

Since: 4.9.0.0

Semigroup a => Semigroup (Identity a)

Since: 4.9.0.0

Semigroup a => Semigroup (Dual a)

Since: 4.9.0.0

Methods

(<>) :: Dual a -> Dual a -> Dual a Source #

sconcat :: NonEmpty (Dual a) -> Dual a Source #

stimes :: Integral b => b -> Dual a -> Dual a Source #

Semigroup (Endo a)

Since: 4.9.0.0

Methods

(<>) :: Endo a -> Endo a -> Endo a Source #

sconcat :: NonEmpty (Endo a) -> Endo a Source #

stimes :: Integral b => b -> Endo a -> Endo a Source #

Num a => Semigroup (Sum a)

Since: 4.9.0.0

Methods

(<>) :: Sum a -> Sum a -> Sum a Source #

sconcat :: NonEmpty (Sum a) -> Sum a Source #

stimes :: Integral b => b -> Sum a -> Sum a Source #

Num a => Semigroup (Product a)

Since: 4.9.0.0

Methods

(<>) :: Product a -> Product a -> Product a Source #

sconcat :: NonEmpty (Product a) -> Product a Source #

stimes :: Integral b => b -> Product a -> Product a Source #

Semigroup (First a)

Since: 4.9.0.0

Methods

(<>) :: First a -> First a -> First a Source #

sconcat :: NonEmpty (First a) -> First a Source #

stimes :: Integral b => b -> First a -> First a Source #

Semigroup (Last a)

Since: 4.9.0.0

Methods

(<>) :: Last a -> Last a -> Last a Source #

sconcat :: NonEmpty (Last a) -> Last a Source #

stimes :: Integral b => b -> Last a -> Last a Source #

Semigroup (IntMap a) 

Methods

(<>) :: IntMap a -> IntMap a -> IntMap a Source #

sconcat :: NonEmpty (IntMap a) -> IntMap a Source #

stimes :: Integral b => b -> IntMap a -> IntMap a Source #

Semigroup (Seq a) 

Methods

(<>) :: Seq a -> Seq a -> Seq a Source #

sconcat :: NonEmpty (Seq a) -> Seq a Source #

stimes :: Integral b => b -> Seq a -> Seq a Source #

Ord a => Semigroup (Set a) 

Methods

(<>) :: Set a -> Set a -> Set a Source #

sconcat :: NonEmpty (Set a) -> Set a Source #

stimes :: Integral b => b -> Set a -> Set a Source #

Semigroup (Doc a) 

Methods

(<>) :: Doc a -> Doc a -> Doc a Source #

sconcat :: NonEmpty (Doc a) -> Doc a Source #

stimes :: Integral b => b -> Doc a -> Doc a Source #

Semigroup (PutM ()) 

Methods

(<>) :: PutM () -> PutM () -> PutM () Source #

sconcat :: NonEmpty (PutM ()) -> PutM () Source #

stimes :: Integral b => b -> PutM () -> PutM () Source #

Semigroup (Last' a) # 

Methods

(<>) :: Last' a -> Last' a -> Last' a Source #

sconcat :: NonEmpty (Last' a) -> Last' a Source #

stimes :: Integral b => b -> Last' a -> Last' a Source #

Semigroup (DList a) # 

Methods

(<>) :: DList a -> DList a -> DList a Source #

sconcat :: NonEmpty (DList a) -> DList a Source #

stimes :: Integral b => b -> DList a -> DList a Source #

Semigroup (Condition a) # 
Semigroup dir => Semigroup (InstallDirs dir) # 
Ord a => Semigroup (NubListR a) # 
Ord a => Semigroup (NubList a) # 

Methods

(<>) :: NubList a -> NubList a -> NubList a Source #

sconcat :: NonEmpty (NubList a) -> NubList a Source #

stimes :: Integral b => b -> NubList a -> NubList a Source #

Semigroup (PackageIndex InstalledPackageInfo) # 
Semigroup (Flag a) # 

Methods

(<>) :: Flag a -> Flag a -> Flag a Source #

sconcat :: NonEmpty (Flag a) -> Flag a Source #

stimes :: Integral b => b -> Flag a -> Flag a Source #

Semigroup b => Semigroup (a -> b)

Since: 4.9.0.0

Methods

(<>) :: (a -> b) -> (a -> b) -> a -> b Source #

sconcat :: NonEmpty (a -> b) -> a -> b Source #

stimes :: Integral b => b -> (a -> b) -> a -> b Source #

Semigroup (Either a b)

Since: 4.9.0.0

Methods

(<>) :: Either a b -> Either a b -> Either a b Source #

sconcat :: NonEmpty (Either a b) -> Either a b Source #

stimes :: Integral b => b -> Either a b -> Either a b Source #

(Semigroup a, Semigroup b) => Semigroup (a, b)

Since: 4.9.0.0

Methods

(<>) :: (a, b) -> (a, b) -> (a, b) Source #

sconcat :: NonEmpty (a, b) -> (a, b) Source #

stimes :: Integral b => b -> (a, b) -> (a, b) Source #

Semigroup (Proxy k s)

Since: 4.9.0.0

Methods

(<>) :: Proxy k s -> Proxy k s -> Proxy k s Source #

sconcat :: NonEmpty (Proxy k s) -> Proxy k s Source #

stimes :: Integral b => b -> Proxy k s -> Proxy k s Source #

Ord k => Semigroup (Map k v) 

Methods

(<>) :: Map k v -> Map k v -> Map k v Source #

sconcat :: NonEmpty (Map k v) -> Map k v Source #

stimes :: Integral b => b -> Map k v -> Map k v Source #

(Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c)

Since: 4.9.0.0

Methods

(<>) :: (a, b, c) -> (a, b, c) -> (a, b, c) Source #

sconcat :: NonEmpty (a, b, c) -> (a, b, c) Source #

stimes :: Integral b => b -> (a, b, c) -> (a, b, c) Source #

Semigroup a => Semigroup (Const k a b)

Since: 4.9.0.0

Methods

(<>) :: Const k a b -> Const k a b -> Const k a b Source #

sconcat :: NonEmpty (Const k a b) -> Const k a b Source #

stimes :: Integral b => b -> Const k a b -> Const k a b Source #

Alternative f => Semigroup (Alt * f a)

Since: 4.9.0.0

Methods

(<>) :: Alt * f a -> Alt * f a -> Alt * f a Source #

sconcat :: NonEmpty (Alt * f a) -> Alt * f a Source #

stimes :: Integral b => b -> Alt * f a -> Alt * f a Source #

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

Since: 4.9.0.0

Methods

(<>) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) Source #

sconcat :: NonEmpty (a, b, c, d) -> (a, b, c, d) Source #

stimes :: Integral b => b -> (a, b, c, d) -> (a, b, c, d) Source #

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

Since: 4.9.0.0

Methods

(<>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) Source #

sconcat :: NonEmpty (a, b, c, d, e) -> (a, b, c, d, e) Source #

stimes :: Integral b => b -> (a, b, c, d, e) -> (a, b, c, d, e) Source #

gmappend :: (Generic a, GSemigroup (Rep a)) => a -> a -> a Source #

Generically generate a Semigroup (<>) operation for any type implementing Generic. This operation will append two values by point-wise appending their component fields. It is only defined for product types.

gmappend a (gmappend b c) = gmappend (gmappend a b) c

gmempty :: (Generic a, GMonoid (Rep a)) => a Source #

Generically generate a Monoid mempty for any product-like type implementing Generic.

It is only defined for product types.

gmappend gmempty a = a = gmappend a gmempty

class Typeable k (a :: k) Source #

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

Minimal complete definition

typeRep#

class Typeable * a => Data a Source #

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

Methods

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

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

toConstr :: Bool -> Constr Source #

dataTypeOf :: Bool -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Char

Since: 4.0.0.0

Methods

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

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

toConstr :: Char -> Constr Source #

dataTypeOf :: Char -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Double

Since: 4.0.0.0

Methods

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

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

toConstr :: Double -> Constr Source #

dataTypeOf :: Double -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Float

Since: 4.0.0.0

Methods

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

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

toConstr :: Float -> Constr Source #

dataTypeOf :: Float -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Int

Since: 4.0.0.0

Methods

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

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

toConstr :: Int -> Constr Source #

dataTypeOf :: Int -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Int8

Since: 4.0.0.0

Methods

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

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

toConstr :: Int8 -> Constr Source #

dataTypeOf :: Int8 -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Int16

Since: 4.0.0.0

Methods

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

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

toConstr :: Int16 -> Constr Source #

dataTypeOf :: Int16 -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Int32

Since: 4.0.0.0

Methods

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

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

toConstr :: Int32 -> Constr Source #

dataTypeOf :: Int32 -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Int64

Since: 4.0.0.0

Methods

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

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

toConstr :: Int64 -> Constr Source #

dataTypeOf :: Int64 -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Integer

Since: 4.0.0.0

Methods

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

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

toConstr :: Integer -> Constr Source #

dataTypeOf :: Integer -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Natural

Since: 4.8.0.0

Methods

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

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

toConstr :: Natural -> Constr Source #

dataTypeOf :: Natural -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Ordering

Since: 4.0.0.0

Methods

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

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

toConstr :: Ordering -> Constr Source #

dataTypeOf :: Ordering -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Word

Since: 4.0.0.0

Methods

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

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

toConstr :: Word -> Constr Source #

dataTypeOf :: Word -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Word8

Since: 4.0.0.0

Methods

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

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

toConstr :: Word8 -> Constr Source #

dataTypeOf :: Word8 -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Word16

Since: 4.0.0.0

Methods

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

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

toConstr :: Word16 -> Constr Source #

dataTypeOf :: Word16 -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Word32

Since: 4.0.0.0

Methods

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

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

toConstr :: Word32 -> Constr Source #

dataTypeOf :: Word32 -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Word64

Since: 4.0.0.0

Methods

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

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

toConstr :: Word64 -> Constr Source #

dataTypeOf :: Word64 -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ()

Since: 4.0.0.0

Methods

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

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

toConstr :: () -> Constr Source #

dataTypeOf :: () -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Void 

Methods

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

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

toConstr :: Void -> Constr Source #

dataTypeOf :: Void -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data SpecConstrAnnotation 

Methods

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

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

toConstr :: SpecConstrAnnotation -> Constr Source #

dataTypeOf :: SpecConstrAnnotation -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Version

Since: 4.7.0.0

Methods

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

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

toConstr :: Version -> Constr Source #

dataTypeOf :: Version -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data All

Since: 4.8.0.0

Methods

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

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

toConstr :: All -> Constr Source #

dataTypeOf :: All -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Any

Since: 4.8.0.0

Methods

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

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

toConstr :: Any -> Constr Source #

dataTypeOf :: Any -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Fixity

Since: 4.9.0.0

Methods

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

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

toConstr :: Fixity -> Constr Source #

dataTypeOf :: Fixity -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Associativity

Since: 4.9.0.0

Methods

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

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

toConstr :: Associativity -> Constr Source #

dataTypeOf :: Associativity -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data SourceUnpackedness

Since: 4.9.0.0

Methods

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

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

toConstr :: SourceUnpackedness -> Constr Source #

dataTypeOf :: SourceUnpackedness -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data SourceStrictness

Since: 4.9.0.0

Methods

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

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

toConstr :: SourceStrictness -> Constr Source #

dataTypeOf :: SourceStrictness -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data DecidedStrictness

Since: 4.9.0.0

Methods

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

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

toConstr :: DecidedStrictness -> Constr Source #

dataTypeOf :: DecidedStrictness -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ByteString 

Methods

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

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

toConstr :: ByteString -> Constr Source #

dataTypeOf :: ByteString -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ShortByteString 

Methods

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

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

toConstr :: ShortByteString -> Constr Source #

dataTypeOf :: ShortByteString -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ByteString 

Methods

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

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

toConstr :: ByteString -> Constr Source #

dataTypeOf :: ByteString -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data IntSet 

Methods

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

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

toConstr :: IntSet -> Constr Source #

dataTypeOf :: IntSet -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ZonedTime 

Methods

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

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

toConstr :: ZonedTime -> Constr Source #

dataTypeOf :: ZonedTime -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data LocalTime 

Methods

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

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

toConstr :: LocalTime -> Constr Source #

dataTypeOf :: LocalTime -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data TimeOfDay 

Methods

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

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

toConstr :: TimeOfDay -> Constr Source #

dataTypeOf :: TimeOfDay -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data TimeZone 

Methods

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

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

toConstr :: TimeZone -> Constr Source #

dataTypeOf :: TimeZone -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data UniversalTime 

Methods

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

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

toConstr :: UniversalTime -> Constr Source #

dataTypeOf :: UniversalTime -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data UTCTime 

Methods

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

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

toConstr :: UTCTime -> Constr Source #

dataTypeOf :: UTCTime -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data NominalDiffTime 

Methods

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

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

toConstr :: NominalDiffTime -> Constr Source #

dataTypeOf :: NominalDiffTime -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Day 

Methods

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

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

toConstr :: Day -> Constr Source #

dataTypeOf :: Day -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Platform # 

Methods

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

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

toConstr :: Platform -> Constr Source #

dataTypeOf :: Platform -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Arch # 

Methods

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

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

toConstr :: Arch -> Constr Source #

dataTypeOf :: Arch -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data OS # 

Methods

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

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

toConstr :: OS -> Constr Source #

dataTypeOf :: OS -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data BuildType # 

Methods

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

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

toConstr :: BuildType -> Constr Source #

dataTypeOf :: BuildType -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ExecutableScope # 

Methods

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

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

toConstr :: ExecutableScope -> Constr Source #

dataTypeOf :: ExecutableScope -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ForeignLibOption # 

Methods

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

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

toConstr :: ForeignLibOption -> Constr Source #

dataTypeOf :: ForeignLibOption -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ForeignLibType # 

Methods

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

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

toConstr :: ForeignLibType -> Constr Source #

dataTypeOf :: ForeignLibType -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data RepoType # 

Methods

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

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

toConstr :: RepoType -> Constr Source #

dataTypeOf :: RepoType -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data RepoKind # 

Methods

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

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

toConstr :: RepoKind -> Constr Source #

dataTypeOf :: RepoKind -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data SourceRepo # 

Methods

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

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

toConstr :: SourceRepo -> Constr Source #

dataTypeOf :: SourceRepo -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ShortText # 

Methods

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

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

toConstr :: ShortText -> Constr Source #

dataTypeOf :: ShortText -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data PkgconfigName # 

Methods

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

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

toConstr :: PkgconfigName -> Constr Source #

dataTypeOf :: PkgconfigName -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ComponentId # 

Methods

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

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

toConstr :: ComponentId -> Constr Source #

dataTypeOf :: ComponentId -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ModuleName # 

Methods

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

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

toConstr :: ModuleName -> Constr Source #

dataTypeOf :: ModuleName -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data ModuleRenaming # 

Methods

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

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

toConstr :: ModuleRenaming -> Constr Source #

dataTypeOf :: ModuleRenaming -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data IncludeRenaming # 

Methods

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

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

toConstr :: IncludeRenaming -> Constr Source #

dataTypeOf :: IncludeRenaming -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data VersionRange # 

Methods

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

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

toConstr :: VersionRange -> Constr Source #

dataTypeOf :: VersionRange -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Version # 

Methods

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

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

toConstr :: Version -> Constr Source #

dataTypeOf :: Version -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data TestType # 

Methods

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

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

toConstr :: TestType -> Constr Source #

dataTypeOf :: TestType -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data TestSuiteInterface # 

Methods

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

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

toConstr :: TestSuiteInterface -> Constr Source #

dataTypeOf :: TestSuiteInterface -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data PkgconfigDependency # 

Methods

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

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

toConstr :: PkgconfigDependency -> Constr Source #

dataTypeOf :: PkgconfigDependency -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data BenchmarkType # 

Methods

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

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

toConstr :: BenchmarkType -> Constr Source #

dataTypeOf :: BenchmarkType -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data BenchmarkInterface # 

Methods

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

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

toConstr :: BenchmarkInterface -> Constr Source #

dataTypeOf :: BenchmarkInterface -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data License # 

Methods

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

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

toConstr :: License -> Constr Source #

dataTypeOf :: License -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data KnownExtension # 

Methods

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

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

toConstr :: KnownExtension -> Constr Source #

dataTypeOf :: KnownExtension -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Extension # 

Methods

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

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

toConstr :: Extension -> Constr Source #

dataTypeOf :: Extension -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Data Language # 

Methods

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

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

toConstr :: Language -> Constr Source #

dataTypeOf :: Language -> DataType Source #

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

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

gmapT :: (forall b. Data b => b -> b) -> Language -> Language Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Language -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Language -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Language -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Language -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Language -> m Language Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Language -> m Language Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Language -> m Language Source #

Data CompilerFlavor # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CompilerFlavor -> c CompilerFlavor Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c CompilerFlavor Source #

toConstr :: CompilerFlavor -> Constr Source #

dataTypeOf :: CompilerFlavor -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c CompilerFlavor) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CompilerFlavor) Source #

gmapT :: (forall b. Data b => b -> b) -> CompilerFlavor -> CompilerFlavor Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CompilerFlavor -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CompilerFlavor -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CompilerFlavor -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CompilerFlavor -> m CompilerFlavor Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CompilerFlavor -> m CompilerFlavor Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CompilerFlavor -> m CompilerFlavor Source #

Data PackageName # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PackageName -> c PackageName Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PackageName Source #

toConstr :: PackageName -> Constr Source #

dataTypeOf :: PackageName -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PackageName) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PackageName) Source #

gmapT :: (forall b. Data b => b -> b) -> PackageName -> PackageName Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PackageName -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PackageName -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> PackageName -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PackageName -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PackageName -> m PackageName Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageName -> m PackageName Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageName -> m PackageName Source #

Data UnqualComponentName # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnqualComponentName -> c UnqualComponentName Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnqualComponentName Source #

toConstr :: UnqualComponentName -> Constr Source #

dataTypeOf :: UnqualComponentName -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c UnqualComponentName) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnqualComponentName) Source #

gmapT :: (forall b. Data b => b -> b) -> UnqualComponentName -> UnqualComponentName Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnqualComponentName -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnqualComponentName -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> UnqualComponentName -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnqualComponentName -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnqualComponentName -> m UnqualComponentName Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnqualComponentName -> m UnqualComponentName Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnqualComponentName -> m UnqualComponentName Source #

Data PackageIdentifier # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PackageIdentifier -> c PackageIdentifier Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PackageIdentifier Source #

toConstr :: PackageIdentifier -> Constr Source #

dataTypeOf :: PackageIdentifier -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PackageIdentifier) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PackageIdentifier) Source #

gmapT :: (forall b. Data b => b -> b) -> PackageIdentifier -> PackageIdentifier Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PackageIdentifier -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PackageIdentifier -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> PackageIdentifier -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PackageIdentifier -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PackageIdentifier -> m PackageIdentifier Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageIdentifier -> m PackageIdentifier Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageIdentifier -> m PackageIdentifier Source #

Data DefUnitId # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DefUnitId -> c DefUnitId Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c DefUnitId Source #

toConstr :: DefUnitId -> Constr Source #

dataTypeOf :: DefUnitId -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c DefUnitId) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DefUnitId) Source #

gmapT :: (forall b. Data b => b -> b) -> DefUnitId -> DefUnitId Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> DefUnitId -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> DefUnitId -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> DefUnitId -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> DefUnitId -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> DefUnitId -> m DefUnitId Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> DefUnitId -> m DefUnitId Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> DefUnitId -> m DefUnitId Source #

Data UnitId # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> UnitId -> c UnitId Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c UnitId Source #

toConstr :: UnitId -> Constr Source #

dataTypeOf :: UnitId -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c UnitId) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UnitId) Source #

gmapT :: (forall b. Data b => b -> b) -> UnitId -> UnitId Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UnitId -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> UnitId -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> UnitId -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> UnitId -> m UnitId Source #

Data Module # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Module -> c Module Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Module Source #

toConstr :: Module -> Constr Source #

dataTypeOf :: Module -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Module) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Module) Source #

gmapT :: (forall b. Data b => b -> b) -> Module -> Module Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Module -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Module -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Module -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Module -> m Module Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Module -> m Module Source #

Data OpenModule # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OpenModule -> c OpenModule Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OpenModule Source #

toConstr :: OpenModule -> Constr Source #

dataTypeOf :: OpenModule -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OpenModule) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpenModule) Source #

gmapT :: (forall b. Data b => b -> b) -> OpenModule -> OpenModule Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OpenModule -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OpenModule -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> OpenModule -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OpenModule -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OpenModule -> m OpenModule Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenModule -> m OpenModule Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenModule -> m OpenModule Source #

Data OpenUnitId # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OpenUnitId -> c OpenUnitId Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OpenUnitId Source #

toConstr :: OpenUnitId -> Constr Source #

dataTypeOf :: OpenUnitId -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c OpenUnitId) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OpenUnitId) Source #

gmapT :: (forall b. Data b => b -> b) -> OpenUnitId -> OpenUnitId Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OpenUnitId -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OpenUnitId -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> OpenUnitId -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> OpenUnitId -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> OpenUnitId -> m OpenUnitId Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenUnitId -> m OpenUnitId Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OpenUnitId -> m OpenUnitId Source #

Data ModuleReexport # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ModuleReexport -> c ModuleReexport Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ModuleReexport Source #

toConstr :: ModuleReexport -> Constr Source #

dataTypeOf :: ModuleReexport -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ModuleReexport) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ModuleReexport) Source #

gmapT :: (forall b. Data b => b -> b) -> ModuleReexport -> ModuleReexport Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ModuleReexport -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ModuleReexport -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ModuleReexport -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ModuleReexport -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ModuleReexport -> m ModuleReexport Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleReexport -> m ModuleReexport Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ModuleReexport -> m ModuleReexport Source #

Data Mixin # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Mixin -> c Mixin Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Mixin Source #

toConstr :: Mixin -> Constr Source #

dataTypeOf :: Mixin -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Mixin) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Mixin) Source #

gmapT :: (forall b. Data b => b -> b) -> Mixin -> Mixin Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Mixin -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Mixin -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Mixin -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Mixin -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Mixin -> m Mixin Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Mixin -> m Mixin Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Mixin -> m Mixin Source #

Data ExeDependency # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ExeDependency -> c ExeDependency Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ExeDependency Source #

toConstr :: ExeDependency -> Constr Source #

dataTypeOf :: ExeDependency -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ExeDependency) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExeDependency) Source #

gmapT :: (forall b. Data b => b -> b) -> ExeDependency -> ExeDependency Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ExeDependency -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ExeDependency -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ExeDependency -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ExeDependency -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ExeDependency -> m ExeDependency Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ExeDependency -> m ExeDependency Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ExeDependency -> m ExeDependency Source #

Data Dependency # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dependency -> c Dependency Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Dependency Source #

toConstr :: Dependency -> Constr Source #

dataTypeOf :: Dependency -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Dependency) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Dependency) Source #

gmapT :: (forall b. Data b => b -> b) -> Dependency -> Dependency Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dependency -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dependency -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Dependency -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dependency -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dependency -> m Dependency Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dependency -> m Dependency Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dependency -> m Dependency Source #

Data SetupBuildInfo # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SetupBuildInfo -> c SetupBuildInfo Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c SetupBuildInfo Source #

toConstr :: SetupBuildInfo -> Constr Source #

dataTypeOf :: SetupBuildInfo -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c SetupBuildInfo) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SetupBuildInfo) Source #

gmapT :: (forall b. Data b => b -> b) -> SetupBuildInfo -> SetupBuildInfo Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SetupBuildInfo -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SetupBuildInfo -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> SetupBuildInfo -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SetupBuildInfo -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SetupBuildInfo -> m SetupBuildInfo Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SetupBuildInfo -> m SetupBuildInfo Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SetupBuildInfo -> m SetupBuildInfo Source #

Data MungedPackageName # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MungedPackageName -> c MungedPackageName Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MungedPackageName Source #

toConstr :: MungedPackageName -> Constr Source #

dataTypeOf :: MungedPackageName -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MungedPackageName) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MungedPackageName) Source #

gmapT :: (forall b. Data b => b -> b) -> MungedPackageName -> MungedPackageName Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MungedPackageName -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MungedPackageName -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> MungedPackageName -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MungedPackageName -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MungedPackageName -> m MungedPackageName Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MungedPackageName -> m MungedPackageName Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MungedPackageName -> m MungedPackageName Source #

Data MungedPackageId # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> MungedPackageId -> c MungedPackageId Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c MungedPackageId Source #

toConstr :: MungedPackageId -> Constr Source #

dataTypeOf :: MungedPackageId -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c MungedPackageId) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MungedPackageId) Source #

gmapT :: (forall b. Data b => b -> b) -> MungedPackageId -> MungedPackageId Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MungedPackageId -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> MungedPackageId -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> MungedPackageId -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> MungedPackageId -> m MungedPackageId Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> MungedPackageId -> m MungedPackageId Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> MungedPackageId -> m MungedPackageId Source #

Data LegacyExeDependency # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LegacyExeDependency -> c LegacyExeDependency Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LegacyExeDependency Source #

toConstr :: LegacyExeDependency -> Constr Source #

dataTypeOf :: LegacyExeDependency -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LegacyExeDependency) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LegacyExeDependency) Source #

gmapT :: (forall b. Data b => b -> b) -> LegacyExeDependency -> LegacyExeDependency Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LegacyExeDependency -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LegacyExeDependency -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> LegacyExeDependency -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LegacyExeDependency -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LegacyExeDependency -> m LegacyExeDependency Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LegacyExeDependency -> m LegacyExeDependency Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LegacyExeDependency -> m LegacyExeDependency Source #

Data BuildInfo # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> BuildInfo -> c BuildInfo Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c BuildInfo Source #

toConstr :: BuildInfo -> Constr Source #

dataTypeOf :: BuildInfo -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c BuildInfo) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BuildInfo) Source #

gmapT :: (forall b. Data b => b -> b) -> BuildInfo -> BuildInfo Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BuildInfo -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BuildInfo -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> BuildInfo -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> BuildInfo -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> BuildInfo -> m BuildInfo Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> BuildInfo -> m BuildInfo Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> BuildInfo -> m BuildInfo Source #

Data TestSuite # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TestSuite -> c TestSuite Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TestSuite Source #

toConstr :: TestSuite -> Constr Source #

dataTypeOf :: TestSuite -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c TestSuite) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TestSuite) Source #

gmapT :: (forall b. Data b => b -> b) -> TestSuite -> TestSuite Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TestSuite -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TestSuite -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> TestSuite -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TestSuite -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TestSuite -> m TestSuite Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TestSuite -> m TestSuite Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TestSuite -> m TestSuite Source #

Data Library # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Library -> c Library Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Library Source #

toConstr :: Library -> Constr Source #

dataTypeOf :: Library -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Library) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Library) Source #

gmapT :: (forall b. Data b => b -> b) -> Library -> Library Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Library -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Library -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Library -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Library -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Library -> m Library Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Library -> m Library Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Library -> m Library Source #

Data LibVersionInfo # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> LibVersionInfo -> c LibVersionInfo Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c LibVersionInfo Source #

toConstr :: LibVersionInfo -> Constr Source #

dataTypeOf :: LibVersionInfo -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c LibVersionInfo) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LibVersionInfo) Source #

gmapT :: (forall b. Data b => b -> b) -> LibVersionInfo -> LibVersionInfo Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LibVersionInfo -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LibVersionInfo -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> LibVersionInfo -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> LibVersionInfo -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> LibVersionInfo -> m LibVersionInfo Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> LibVersionInfo -> m LibVersionInfo Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> LibVersionInfo -> m LibVersionInfo Source #

Data ForeignLib # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignLib -> c ForeignLib Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ForeignLib Source #

toConstr :: ForeignLib -> Constr Source #

dataTypeOf :: ForeignLib -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ForeignLib) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ForeignLib) Source #

gmapT :: (forall b. Data b => b -> b) -> ForeignLib -> ForeignLib Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignLib -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignLib -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ForeignLib -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignLib -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignLib -> m ForeignLib Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignLib -> m ForeignLib Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignLib -> m ForeignLib Source #

Data Executable # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Executable -> c Executable Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Executable Source #

toConstr :: Executable -> Constr Source #

dataTypeOf :: Executable -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Executable) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Executable) Source #

gmapT :: (forall b. Data b => b -> b) -> Executable -> Executable Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Executable -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Executable -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Executable -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Executable -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Executable -> m Executable Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Executable -> m Executable Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Executable -> m Executable Source #

Data Benchmark # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Benchmark -> c Benchmark Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Benchmark Source #

toConstr :: Benchmark -> Constr Source #

dataTypeOf :: Benchmark -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Benchmark) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Benchmark) Source #

gmapT :: (forall b. Data b => b -> b) -> Benchmark -> Benchmark Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Benchmark -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Benchmark -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Benchmark -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Benchmark -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Benchmark -> m Benchmark Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Benchmark -> m Benchmark Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Benchmark -> m Benchmark Source #

Data PackageDescription # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PackageDescription -> c PackageDescription Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PackageDescription Source #

toConstr :: PackageDescription -> Constr Source #

dataTypeOf :: PackageDescription -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c PackageDescription) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PackageDescription) Source #

gmapT :: (forall b. Data b => b -> b) -> PackageDescription -> PackageDescription Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PackageDescription -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PackageDescription -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> PackageDescription -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> PackageDescription -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PackageDescription -> m PackageDescription Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageDescription -> m PackageDescription Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PackageDescription -> m PackageDescription Source #

Data ConfVar # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConfVar -> c ConfVar Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConfVar Source #

toConstr :: ConfVar -> Constr Source #

dataTypeOf :: ConfVar -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ConfVar) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConfVar) Source #

gmapT :: (forall b. Data b => b -> b) -> ConfVar -> ConfVar Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConfVar -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConfVar -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ConfVar -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ConfVar -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConfVar -> m ConfVar Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConfVar -> m ConfVar Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConfVar -> m ConfVar Source #

Data FlagName # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FlagName -> c FlagName Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FlagName Source #

toConstr :: FlagName -> Constr Source #

dataTypeOf :: FlagName -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c FlagName) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FlagName) Source #

gmapT :: (forall b. Data b => b -> b) -> FlagName -> FlagName Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FlagName -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FlagName -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> FlagName -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> FlagName -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FlagName -> m FlagName Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FlagName -> m FlagName Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FlagName -> m FlagName Source #

Data Flag # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Flag -> c Flag Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Flag Source #

toConstr :: Flag -> Constr Source #

dataTypeOf :: Flag -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Flag) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Flag) Source #

gmapT :: (forall b. Data b => b -> b) -> Flag -> Flag Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Flag -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Flag -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Flag -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Flag -> m Flag Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Flag -> m Flag Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Flag -> m Flag Source #

Data GenericPackageDescription # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GenericPackageDescription -> c GenericPackageDescription Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GenericPackageDescription Source #

toConstr :: GenericPackageDescription -> Constr Source #

dataTypeOf :: GenericPackageDescription -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c GenericPackageDescription) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GenericPackageDescription) Source #

gmapT :: (forall b. Data b => b -> b) -> GenericPackageDescription -> GenericPackageDescription Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GenericPackageDescription -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GenericPackageDescription -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> GenericPackageDescription -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> GenericPackageDescription -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GenericPackageDescription -> m GenericPackageDescription Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GenericPackageDescription -> m GenericPackageDescription Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GenericPackageDescription -> m GenericPackageDescription Source #

Data a => Data [a]

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> [a] -> c [a] Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c [a] Source #

toConstr :: [a] -> Constr Source #

dataTypeOf :: [a] -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c [a]) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c [a]) Source #

gmapT :: (forall b. Data b => b -> b) -> [a] -> [a] Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> [a] -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> [a] -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> [a] -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> [a] -> m [a] Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> [a] -> m [a] Source #

Data a => Data (Maybe a)

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) Source #

toConstr :: Maybe a -> Constr Source #

dataTypeOf :: Maybe a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) Source #

(Data a, Integral a) => Data (Ratio a)

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ratio a -> c (Ratio a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ratio a) Source #

toConstr :: Ratio a -> Constr Source #

dataTypeOf :: Ratio a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Ratio a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ratio a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Ratio a -> Ratio a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Ratio a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ratio a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) Source #

Data a => Data (Ptr a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptr a -> c (Ptr a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ptr a) Source #

toConstr :: Ptr a -> Constr Source #

dataTypeOf :: Ptr a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Ptr a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ptr a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Ptr a -> Ptr a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptr a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Ptr a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptr a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptr a -> m (Ptr a) Source #

Data p => Data (Par1 p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Par1 p -> c (Par1 p) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Par1 p) Source #

toConstr :: Par1 p -> Constr Source #

dataTypeOf :: Par1 p -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Par1 p)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Par1 p)) Source #

gmapT :: (forall b. Data b => b -> b) -> Par1 p -> Par1 p Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Par1 p -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Par1 p -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Par1 p -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Par1 p -> m (Par1 p) Source #

Data a => Data (ForeignPtr a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ForeignPtr a -> c (ForeignPtr a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ForeignPtr a) Source #

toConstr :: ForeignPtr a -> Constr Source #

dataTypeOf :: ForeignPtr a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ForeignPtr a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ForeignPtr a)) Source #

gmapT :: (forall b. Data b => b -> b) -> ForeignPtr a -> ForeignPtr a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ForeignPtr a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ForeignPtr a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ForeignPtr a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ForeignPtr a -> m (ForeignPtr a) Source #

Data a => Data (Complex a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) Source #

toConstr :: Complex a -> Constr Source #

dataTypeOf :: Complex a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) Source #

Typeable * a => Data (Fixed a)

Since: 4.1.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixed a -> c (Fixed a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Fixed a) Source #

toConstr :: Fixed a -> Constr Source #

dataTypeOf :: Fixed a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Fixed a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Fixed a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Fixed a -> Fixed a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Fixed a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Fixed a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Fixed a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Fixed a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Fixed a -> m (Fixed a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixed a -> m (Fixed a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Fixed a -> m (Fixed a) Source #

Data a => Data (Min a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Min a -> c (Min a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Min a) Source #

toConstr :: Min a -> Constr Source #

dataTypeOf :: Min a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Min a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Min a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Min a -> Min a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Min a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Min a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Min a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Min a -> m (Min a) Source #

Data a => Data (Max a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Max a -> c (Max a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Max a) Source #

toConstr :: Max a -> Constr Source #

dataTypeOf :: Max a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Max a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Max a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Max a -> Max a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Max a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Max a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Max a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Max a -> m (Max a) Source #

Data a => Data (First a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) Source #

toConstr :: First a -> Constr Source #

dataTypeOf :: First a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) Source #

gmapT :: (forall b. Data b => b -> b) -> First a -> First a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #

Data a => Data (Last a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) Source #

toConstr :: Last a -> Constr Source #

dataTypeOf :: Last a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #

Data m => Data (WrappedMonoid m) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> WrappedMonoid m -> c (WrappedMonoid m) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (WrappedMonoid m) Source #

toConstr :: WrappedMonoid m -> Constr Source #

dataTypeOf :: WrappedMonoid m -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (WrappedMonoid m)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (WrappedMonoid m)) Source #

gmapT :: (forall b. Data b => b -> b) -> WrappedMonoid m -> WrappedMonoid m Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> WrappedMonoid m -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> WrappedMonoid m -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> WrappedMonoid m -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> WrappedMonoid m -> m (WrappedMonoid m) Source #

Data a => Data (Option a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Option a -> c (Option a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Option a) Source #

toConstr :: Option a -> Constr Source #

dataTypeOf :: Option a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Option a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Option a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Option a -> Option a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Option a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Option a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Option a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Option a -> m (Option a) Source #

Data a => Data (NonEmpty a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> NonEmpty a -> c (NonEmpty a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (NonEmpty a) Source #

toConstr :: NonEmpty a -> Constr Source #

dataTypeOf :: NonEmpty a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (NonEmpty a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (NonEmpty a)) Source #

gmapT :: (forall b. Data b => b -> b) -> NonEmpty a -> NonEmpty a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NonEmpty a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> NonEmpty a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmpty a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> NonEmpty a -> m (NonEmpty a) Source #

Data a => Data (Identity a)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Identity a -> c (Identity a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Identity a) Source #

toConstr :: Identity a -> Constr Source #

dataTypeOf :: Identity a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Identity a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Identity a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Identity a -> Identity a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Identity a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Identity a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a) Source #

Data a => Data (Dual a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dual a -> c (Dual a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dual a) Source #

toConstr :: Dual a -> Constr Source #

dataTypeOf :: Dual a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Dual a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dual a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Dual a -> Dual a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Dual a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dual a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) Source #

Data a => Data (Sum a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sum a -> c (Sum a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum a) Source #

toConstr :: Sum a -> Constr Source #

dataTypeOf :: Sum a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Sum a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Sum a -> Sum a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Sum a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) Source #

Data a => Data (Product a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Product a -> c (Product a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product a) Source #

toConstr :: Product a -> Constr Source #

dataTypeOf :: Product a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Product a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Product a -> Product a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Product a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Product a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) Source #

Data a => Data (First a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) Source #

toConstr :: First a -> Constr Source #

dataTypeOf :: First a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) Source #

gmapT :: (forall b. Data b => b -> b) -> First a -> First a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #

Data a => Data (Last a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) Source #

toConstr :: Last a -> Constr Source #

dataTypeOf :: Last a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #

Data a => Data (IntMap a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IntMap a -> c (IntMap a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (IntMap a) Source #

toConstr :: IntMap a -> Constr Source #

dataTypeOf :: IntMap a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (IntMap a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (IntMap a)) Source #

gmapT :: (forall b. Data b => b -> b) -> IntMap a -> IntMap a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IntMap a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> IntMap a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> IntMap a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IntMap a -> m (IntMap a) Source #

Data vertex => Data (SCC vertex) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SCC vertex -> c (SCC vertex) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (SCC vertex) Source #

toConstr :: SCC vertex -> Constr Source #

dataTypeOf :: SCC vertex -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (SCC vertex)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SCC vertex)) Source #

gmapT :: (forall b. Data b => b -> b) -> SCC vertex -> SCC vertex Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SCC vertex -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SCC vertex -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> SCC vertex -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> SCC vertex -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> SCC vertex -> m (SCC vertex) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> SCC vertex -> m (SCC vertex) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> SCC vertex -> m (SCC vertex) Source #

Data a => Data (Tree a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tree a -> c (Tree a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Tree a) Source #

toConstr :: Tree a -> Constr Source #

dataTypeOf :: Tree a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Tree a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Tree a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Tree a -> Tree a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tree a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tree a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Tree a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Tree a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tree a -> m (Tree a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tree a -> m (Tree a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tree a -> m (Tree a) Source #

Data a => Data (Seq a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Seq a -> c (Seq a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Seq a) Source #

toConstr :: Seq a -> Constr Source #

dataTypeOf :: Seq a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Seq a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Seq a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Seq a -> Seq a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Seq a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Seq a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Seq a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Seq a -> m (Seq a) Source #

Data a => Data (ViewL a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ViewL a -> c (ViewL a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ViewL a) Source #

toConstr :: ViewL a -> Constr Source #

dataTypeOf :: ViewL a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ViewL a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ViewL a)) Source #

gmapT :: (forall b. Data b => b -> b) -> ViewL a -> ViewL a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ViewL a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ViewL a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ViewL a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ViewL a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ViewL a -> m (ViewL a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewL a -> m (ViewL a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewL a -> m (ViewL a) Source #

Data a => Data (ViewR a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ViewR a -> c (ViewR a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ViewR a) Source #

toConstr :: ViewR a -> Constr Source #

dataTypeOf :: ViewR a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (ViewR a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ViewR a)) Source #

gmapT :: (forall b. Data b => b -> b) -> ViewR a -> ViewR a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ViewR a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ViewR a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> ViewR a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> ViewR a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ViewR a -> m (ViewR a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewR a -> m (ViewR a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ViewR a -> m (ViewR a) Source #

(Data a, Ord a) => Data (Set a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Set a -> c (Set a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Set a) Source #

toConstr :: Set a -> Constr Source #

dataTypeOf :: Set a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Set a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Set a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Set a -> Set a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Set a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Set a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) Source #

Data c => Data (Condition c) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Condition c -> c (Condition c) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Condition c) Source #

toConstr :: Condition c -> Constr Source #

dataTypeOf :: Condition c -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Condition c)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Condition c)) Source #

gmapT :: (forall b. Data b => b -> b) -> Condition c -> Condition c Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Condition c -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Condition c -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Condition c -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Condition c -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Condition c -> m (Condition c) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Condition c -> m (Condition c) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Condition c -> m (Condition c) Source #

(Data a, Data b) => Data (Either a b)

Since: 4.0.0.0

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Either a b -> c (Either a b) Source #

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) Source #

toConstr :: Either a b -> Constr Source #

dataTypeOf :: Either a b -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) Source #

gmapT :: (forall c. Data c => c -> c) -> Either a b -> Either a b Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) Source #

Data p => Data (V1 * p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 * p -> c (V1 * p) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (V1 * p) Source #

toConstr :: V1 * p -> Constr Source #

dataTypeOf :: V1 * p -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (V1 * p)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (V1 * p)) Source #

gmapT :: (forall b. Data b => b -> b) -> V1 * p -> V1 * p Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> V1 * p -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> V1 * p -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> V1 * p -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> V1 * p -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> V1 * p -> m (V1 * p) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 * p -> m (V1 * p) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> V1 * p -> m (V1 * p) Source #

Data p => Data (U1 * p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> U1 * p -> c (U1 * p) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (U1 * p) Source #

toConstr :: U1 * p -> Constr Source #

dataTypeOf :: U1 * p -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (U1 * p)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (U1 * p)) Source #

gmapT :: (forall b. Data b => b -> b) -> U1 * p -> U1 * p Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> U1 * p -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> U1 * p -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> U1 * p -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> U1 * p -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> U1 * p -> m (U1 * p) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 * p -> m (U1 * p) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> U1 * p -> m (U1 * p) Source #

(Data a, Data b) => Data (a, b)

Since: 4.0.0.0

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> (a, b) -> c (a, b) Source #

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b) Source #

toConstr :: (a, b) -> Constr Source #

dataTypeOf :: (a, b) -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (a, b)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a, b)) Source #

gmapT :: (forall c. Data c => c -> c) -> (a, b) -> (a, b) Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b) -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> (a, b) -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b) -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b) -> m (a, b) Source #

(Data a, Data b, Ix a) => Data (Array a b)

Since: 4.8.0.0

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Array a b -> c (Array a b) Source #

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array a b) Source #

toConstr :: Array a b -> Constr Source #

dataTypeOf :: Array a b -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Array a b)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a b)) Source #

gmapT :: (forall c. Data c => c -> c) -> Array a b -> Array a b Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Array a b -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Array a b -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) Source #

(Data b, Data a) => Data (Arg a b) 

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Arg a b -> c (Arg a b) Source #

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Arg a b) Source #

toConstr :: Arg a b -> Constr Source #

dataTypeOf :: Arg a b -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Arg a b)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Arg a b)) Source #

gmapT :: (forall c. Data c => c -> c) -> Arg a b -> Arg a b Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Arg a b -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Arg a b -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Arg a b -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Arg a b -> m (Arg a b) Source #

Data t => Data (Proxy * t)

Since: 4.7.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Proxy * t -> c (Proxy * t) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Proxy * t) Source #

toConstr :: Proxy * t -> Constr Source #

dataTypeOf :: Proxy * t -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Proxy * t)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Proxy * t)) Source #

gmapT :: (forall b. Data b => b -> b) -> Proxy * t -> Proxy * t Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Proxy * t -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Proxy * t -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Proxy * t -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Proxy * t -> m (Proxy * t) Source #

(Data k, Data a, Ord k) => Data (Map k a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Map k a -> c (Map k a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Map k a) Source #

toConstr :: Map k a -> Constr Source #

dataTypeOf :: Map k a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Map k a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Map k a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Map k a -> Map k a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Map k a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Map k a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) Source #

(Data (f p), Typeable (* -> *) f, Data p) => Data (Rec1 * f p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rec1 * f p -> c (Rec1 * f p) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Rec1 * f p) Source #

toConstr :: Rec1 * f p -> Constr Source #

dataTypeOf :: Rec1 * f p -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Rec1 * f p)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Rec1 * f p)) Source #

gmapT :: (forall b. Data b => b -> b) -> Rec1 * f p -> Rec1 * f p Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 * f p -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rec1 * f p -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Rec1 * f p -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Rec1 * f p -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rec1 * f p -> m (Rec1 * f p) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 * f p -> m (Rec1 * f p) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rec1 * f p -> m (Rec1 * f p) Source #

(Data a, Data b, Data c) => Data (a, b, c)

Since: 4.0.0.0

Methods

gfoldl :: (forall d e. Data d => c (d -> e) -> d -> c e) -> (forall g. g -> c g) -> (a, b, c) -> c (a, b, c) Source #

gunfold :: (forall d r. Data d => c (d -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b, c) Source #

toConstr :: (a, b, c) -> Constr Source #

dataTypeOf :: (a, b, c) -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (a, b, c)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (a, b, c)) Source #

gmapT :: (forall d. Data d => d -> d) -> (a, b, c) -> (a, b, c) Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (a, b, c) -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> (a, b, c) -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (a, b, c) -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (a, b, c) -> m (a, b, c) Source #

(Typeable * k3, Data a, Typeable k3 b) => Data (Const k3 a b)

Since: 4.10.0.0

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Const k3 a b -> c (Const k3 a b) Source #

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Const k3 a b) Source #

toConstr :: Const k3 a b -> Constr Source #

dataTypeOf :: Const k3 a b -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Const k3 a b)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Const k3 a b)) Source #

gmapT :: (forall c. Data c => c -> c) -> Const k3 a b -> Const k3 a b Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Const k3 a b -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Const k3 a b -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Const k3 a b -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Const k3 a b -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Const k3 a b -> m (Const k3 a b) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Const k3 a b -> m (Const k3 a b) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Const k3 a b -> m (Const k3 a b) Source #

(Data (f a), Data a, Typeable (* -> *) f) => Data (Alt * f a)

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt * f a -> c (Alt * f a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt * f a) Source #

toConstr :: Alt * f a -> Constr Source #

dataTypeOf :: Alt * f a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Alt * f a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt * f a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Alt * f a -> Alt * f a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt * f a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Alt * f a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt * f a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt * f a -> m (Alt * f a) Source #

(Coercible * a b, Data a, Data b) => Data (Coercion * a b)

Since: 4.7.0.0

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Coercion * a b -> c (Coercion * a b) Source #

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Coercion * a b) Source #

toConstr :: Coercion * a b -> Constr Source #

dataTypeOf :: Coercion * a b -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Coercion * a b)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Coercion * a b)) Source #

gmapT :: (forall c. Data c => c -> c) -> Coercion * a b -> Coercion * a b Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Coercion * a b -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Coercion * a b -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Coercion * a b -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Coercion * a b -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Coercion * a b -> m (Coercion * a b) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion * a b -> m (Coercion * a b) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Coercion * a b -> m (Coercion * a b) Source #

((~) * a b, Data a) => Data ((:~:) * a b)

Since: 4.7.0.0

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> (* :~: a) b -> c ((* :~: a) b) Source #

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((* :~: a) b) Source #

toConstr :: (* :~: a) b -> Constr Source #

dataTypeOf :: (* :~: a) b -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((* :~: a) b)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :~: a) b)) Source #

gmapT :: (forall c. Data c => c -> c) -> (* :~: a) b -> (* :~: a) b Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :~: a) b -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (* :~: a) b -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> (* :~: a) b -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (* :~: a) b -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: a) b) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: a) b) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :~: a) b -> m ((* :~: a) b) Source #

(Data a, Data c, Data v) => Data (CondBranch v c a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CondBranch v c a -> c (CondBranch v c a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CondBranch v c a) Source #

toConstr :: CondBranch v c a -> Constr Source #

dataTypeOf :: CondBranch v c a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CondBranch v c a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CondBranch v c a)) Source #

gmapT :: (forall b. Data b => b -> b) -> CondBranch v c a -> CondBranch v c a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CondBranch v c a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CondBranch v c a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CondBranch v c a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CondBranch v c a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CondBranch v c a -> m (CondBranch v c a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CondBranch v c a -> m (CondBranch v c a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CondBranch v c a -> m (CondBranch v c a) Source #

(Data a, Data c, Data v) => Data (CondTree v c a) # 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> CondTree v c a -> c (CondTree v c a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (CondTree v c a) Source #

toConstr :: CondTree v c a -> Constr Source #

dataTypeOf :: CondTree v c a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (CondTree v c a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (CondTree v c a)) Source #

gmapT :: (forall b. Data b => b -> b) -> CondTree v c a -> CondTree v c a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CondTree v c a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CondTree v c a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> CondTree v c a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> CondTree v c a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> CondTree v c a -> m (CondTree v c a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> CondTree v c a -> m (CondTree v c a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> CondTree v c a -> m (CondTree v c a) Source #

(Typeable * i, Data p, Data c) => Data (K1 * i c p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> K1 * i c p -> c (K1 * i c p) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (K1 * i c p) Source #

toConstr :: K1 * i c p -> Constr Source #

dataTypeOf :: K1 * i c p -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (K1 * i c p)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (K1 * i c p)) Source #

gmapT :: (forall b. Data b => b -> b) -> K1 * i c p -> K1 * i c p Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> K1 * i c p -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> K1 * i c p -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> K1 * i c p -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> K1 * i c p -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> K1 * i c p -> m (K1 * i c p) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 * i c p -> m (K1 * i c p) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> K1 * i c p -> m (K1 * i c p) Source #

(Typeable (* -> *) f, Typeable (* -> *) g, Data p, Data (f p), Data (g p)) => Data ((:+:) * f g p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (* :+: f) g p -> c ((* :+: f) g p) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((* :+: f) g p) Source #

toConstr :: (* :+: f) g p -> Constr Source #

dataTypeOf :: (* :+: f) g p -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((* :+: f) g p)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :+: f) g p)) Source #

gmapT :: (forall b. Data b => b -> b) -> (* :+: f) g p -> (* :+: f) g p Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :+: f) g p -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (* :+: f) g p -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> (* :+: f) g p -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (* :+: f) g p -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (* :+: f) g p -> m ((* :+: f) g p) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :+: f) g p -> m ((* :+: f) g p) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :+: f) g p -> m ((* :+: f) g p) Source #

(Typeable (* -> *) f, Typeable (* -> *) g, Data p, Data (f p), Data (g p)) => Data ((:*:) * f g p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (* :*: f) g p -> c ((* :*: f) g p) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((* :*: f) g p) Source #

toConstr :: (* :*: f) g p -> Constr Source #

dataTypeOf :: (* :*: f) g p -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((* :*: f) g p)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :*: f) g p)) Source #

gmapT :: (forall b. Data b => b -> b) -> (* :*: f) g p -> (* :*: f) g p Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :*: f) g p -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (* :*: f) g p -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> (* :*: f) g p -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (* :*: f) g p -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (* :*: f) g p -> m ((* :*: f) g p) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :*: f) g p -> m ((* :*: f) g p) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :*: f) g p -> m ((* :*: f) g p) Source #

(Data a, Data b, Data c, Data d) => Data (a, b, c, d)

Since: 4.0.0.0

Methods

gfoldl :: (forall e f. Data e => c (e -> f) -> e -> c f) -> (forall g. g -> c g) -> (a, b, c, d) -> c (a, b, c, d) Source #

gunfold :: (forall e r. Data e => c (e -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b, c, d) Source #

toConstr :: (a, b, c, d) -> Constr Source #

dataTypeOf :: (a, b, c, d) -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall e. Data e => c (t e)) -> Maybe (c (a, b, c, d)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall e f. (Data e, Data f) => c (t e f)) -> Maybe (c (a, b, c, d)) Source #

gmapT :: (forall e. Data e => e -> e) -> (a, b, c, d) -> (a, b, c, d) Source #

gmapQl :: (r -> r' -> r) -> r -> (forall e. Data e => e -> r') -> (a, b, c, d) -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall e. Data e => e -> r') -> (a, b, c, d) -> r Source #

gmapQ :: (forall e. Data e => e -> u) -> (a, b, c, d) -> [u] Source #

gmapQi :: Int -> (forall e. Data e => e -> u) -> (a, b, c, d) -> u Source #

gmapM :: Monad m => (forall e. Data e => e -> m e) -> (a, b, c, d) -> m (a, b, c, d) Source #

gmapMp :: MonadPlus m => (forall e. Data e => e -> m e) -> (a, b, c, d) -> m (a, b, c, d) Source #

gmapMo :: MonadPlus m => (forall e. Data e => e -> m e) -> (a, b, c, d) -> m (a, b, c, d) Source #

(Data (g a), Data (f a), Typeable * k, Typeable (k -> *) g, Typeable (k -> *) f, Typeable k a) => Data (Product k f g a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall b. b -> c b) -> Product k f g a -> c (Product k f g a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product k f g a) Source #

toConstr :: Product k f g a -> Constr Source #

dataTypeOf :: Product k f g a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Product k f g a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product k f g a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Product k f g a -> Product k f g a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product k f g a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product k f g a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Product k f g a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Product k f g a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product k f g a -> m (Product k f g a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product k f g a -> m (Product k f g a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product k f g a -> m (Product k f g a) Source #

(Data (g a), Data (f a), Typeable * k, Typeable (k -> *) g, Typeable (k -> *) f, Typeable k a) => Data (Sum k f g a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall b. b -> c b) -> Sum k f g a -> c (Sum k f g a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum k f g a) Source #

toConstr :: Sum k f g a -> Constr Source #

dataTypeOf :: Sum k f g a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Sum k f g a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum k f g a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Sum k f g a -> Sum k f g a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum k f g a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum k f g a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Sum k f g a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum k f g a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum k f g a -> m (Sum k f g a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum k f g a -> m (Sum k f g a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum k f g a -> m (Sum k f g a) Source #

(Typeable * i2, Typeable * j2, Typeable i2 a, Typeable j2 b, (~~) i2 j2 a b) => Data ((:~~:) i2 j2 a b)

Since: 4.10.0.0

Methods

gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> (i2 :~~: j2) a b -> c ((i2 :~~: j2) a b) Source #

gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((i2 :~~: j2) a b) Source #

toConstr :: (i2 :~~: j2) a b -> Constr Source #

dataTypeOf :: (i2 :~~: j2) a b -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((i2 :~~: j2) a b)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((i2 :~~: j2) a b)) Source #

gmapT :: (forall c. Data c => c -> c) -> (i2 :~~: j2) a b -> (i2 :~~: j2) a b Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (i2 :~~: j2) a b -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (i2 :~~: j2) a b -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> (i2 :~~: j2) a b -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (i2 :~~: j2) a b -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (i2 :~~: j2) a b -> m ((i2 :~~: j2) a b) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (i2 :~~: j2) a b -> m ((i2 :~~: j2) a b) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (i2 :~~: j2) a b -> m ((i2 :~~: j2) a b) Source #

(Data p, Data (f p), Typeable Meta c, Typeable * i, Typeable (* -> *) f) => Data (M1 * i c f p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> M1 * i c f p -> c (M1 * i c f p) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (M1 * i c f p) Source #

toConstr :: M1 * i c f p -> Constr Source #

dataTypeOf :: M1 * i c f p -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (M1 * i c f p)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (M1 * i c f p)) Source #

gmapT :: (forall b. Data b => b -> b) -> M1 * i c f p -> M1 * i c f p Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> M1 * i c f p -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> M1 * i c f p -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> M1 * i c f p -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> M1 * i c f p -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> M1 * i c f p -> m (M1 * i c f p) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 * i c f p -> m (M1 * i c f p) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> M1 * i c f p -> m (M1 * i c f p) Source #

(Typeable (* -> *) f, Typeable (* -> *) g, Data p, Data (f (g p))) => Data ((:.:) * * f g p)

Since: 4.9.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall a. a -> c a) -> (* :.: *) f g p -> c ((* :.: *) f g p) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ((* :.: *) f g p) Source #

toConstr :: (* :.: *) f g p -> Constr Source #

dataTypeOf :: (* :.: *) f g p -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c ((* :.: *) f g p)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ((* :.: *) f g p)) Source #

gmapT :: (forall b. Data b => b -> b) -> (* :.: *) f g p -> (* :.: *) f g p Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (* :.: *) f g p -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (* :.: *) f g p -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> (* :.: *) f g p -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> (* :.: *) f g p -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (* :.: *) f g p -> m ((* :.: *) f g p) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :.: *) f g p -> m ((* :.: *) f g p) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (* :.: *) f g p -> m ((* :.: *) f g p) Source #

(Data a, Data b, Data c, Data d, Data e) => Data (a, b, c, d, e)

Since: 4.0.0.0

Methods

gfoldl :: (forall f g. Data f => c (f -> g) -> f -> c g) -> (forall g. g -> c g) -> (a, b, c, d, e) -> c (a, b, c, d, e) Source #

gunfold :: (forall f r. Data f => c (f -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b, c, d, e) Source #

toConstr :: (a, b, c, d, e) -> Constr Source #

dataTypeOf :: (a, b, c, d, e) -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall f. Data f => c (t f)) -> Maybe (c (a, b, c, d, e)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall f g. (Data f, Data g) => c (t f g)) -> Maybe (c (a, b, c, d, e)) Source #

gmapT :: (forall f. Data f => f -> f) -> (a, b, c, d, e) -> (a, b, c, d, e) Source #

gmapQl :: (r -> r' -> r) -> r -> (forall f. Data f => f -> r') -> (a, b, c, d, e) -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall f. Data f => f -> r') -> (a, b, c, d, e) -> r Source #

gmapQ :: (forall f. Data f => f -> u) -> (a, b, c, d, e) -> [u] Source #

gmapQi :: Int -> (forall f. Data f => f -> u) -> (a, b, c, d, e) -> u Source #

gmapM :: Monad m => (forall f. Data f => f -> m f) -> (a, b, c, d, e) -> m (a, b, c, d, e) Source #

gmapMp :: MonadPlus m => (forall f. Data f => f -> m f) -> (a, b, c, d, e) -> m (a, b, c, d, e) Source #

gmapMo :: MonadPlus m => (forall f. Data f => f -> m f) -> (a, b, c, d, e) -> m (a, b, c, d, e) Source #

(Data (f (g a)), Typeable * k2, Typeable * k1, Typeable (k2 -> k1) g, Typeable (k1 -> *) f, Typeable k2 a) => Data (Compose k1 k2 f g a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall b. b -> c b) -> Compose k1 k2 f g a -> c (Compose k1 k2 f g a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Compose k1 k2 f g a) Source #

toConstr :: Compose k1 k2 f g a -> Constr Source #

dataTypeOf :: Compose k1 k2 f g a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Compose k1 k2 f g a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Compose k1 k2 f g a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Compose k1 k2 f g a -> Compose k1 k2 f g a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Compose k1 k2 f g a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Compose k1 k2 f g a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Compose k1 k2 f g a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Compose k1 k2 f g a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Compose k1 k2 f g a -> m (Compose k1 k2 f g a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose k1 k2 f g a -> m (Compose k1 k2 f g a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Compose k1 k2 f g a -> m (Compose k1 k2 f g a) Source #

(Data a, Data b, Data c, Data d, Data e, Data f) => Data (a, b, c, d, e, f)

Since: 4.0.0.0

Methods

gfoldl :: (forall g h. Data g => c (g -> h) -> g -> c h) -> (forall g. g -> c g) -> (a, b, c, d, e, f) -> c (a, b, c, d, e, f) Source #

gunfold :: (forall g r. Data g => c (g -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b, c, d, e, f) Source #

toConstr :: (a, b, c, d, e, f) -> Constr Source #

dataTypeOf :: (a, b, c, d, e, f) -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall g. Data g => c (t g)) -> Maybe (c (a, b, c, d, e, f)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall g h. (Data g, Data h) => c (t g h)) -> Maybe (c (a, b, c, d, e, f)) Source #

gmapT :: (forall g. Data g => g -> g) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f) Source #

gmapQl :: (r -> r' -> r) -> r -> (forall g. Data g => g -> r') -> (a, b, c, d, e, f) -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall g. Data g => g -> r') -> (a, b, c, d, e, f) -> r Source #

gmapQ :: (forall g. Data g => g -> u) -> (a, b, c, d, e, f) -> [u] Source #

gmapQi :: Int -> (forall g. Data g => g -> u) -> (a, b, c, d, e, f) -> u Source #

gmapM :: Monad m => (forall g. Data g => g -> m g) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) Source #

gmapMp :: MonadPlus m => (forall g. Data g => g -> m g) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) Source #

gmapMo :: MonadPlus m => (forall g. Data g => g -> m g) -> (a, b, c, d, e, f) -> m (a, b, c, d, e, f) Source #

(Data a, Data b, Data c, Data d, Data e, Data f, Data g) => Data (a, b, c, d, e, f, g)

Since: 4.0.0.0

Methods

gfoldl :: (forall h i. Data h => c (h -> i) -> h -> c i) -> (forall h. h -> c h) -> (a, b, c, d, e, f, g) -> c (a, b, c, d, e, f, g) Source #

gunfold :: (forall h r. Data h => c (h -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (a, b, c, d, e, f, g) Source #

toConstr :: (a, b, c, d, e, f, g) -> Constr Source #

dataTypeOf :: (a, b, c, d, e, f, g) -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall h. Data h => c (t h)) -> Maybe (c (a, b, c, d, e, f, g)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall h i. (Data h, Data i) => c (t h i)) -> Maybe (c (a, b, c, d, e, f, g)) Source #

gmapT :: (forall h. Data h => h -> h) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) Source #

gmapQl :: (r -> r' -> r) -> r -> (forall h. Data h => h -> r') -> (a, b, c, d, e, f, g) -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall h. Data h => h -> r') -> (a, b, c, d, e, f, g) -> r Source #

gmapQ :: (forall h. Data h => h -> u) -> (a, b, c, d, e, f, g) -> [u] Source #

gmapQi :: Int -> (forall h. Data h => h -> u) -> (a, b, c, d, e, f, g) -> u Source #

gmapM :: Monad m => (forall h. Data h => h -> m h) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) Source #

gmapMp :: MonadPlus m => (forall h. Data h => h -> m h) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) Source #

gmapMo :: MonadPlus m => (forall h. Data h => h -> m h) -> (a, b, c, d, e, f, g) -> m (a, b, c, d, e, f, g) Source #

class Generic a Source #

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

Minimal complete definition

from, to

Instances

Generic Bool 

Associated Types

type Rep Bool :: * -> * Source #

Methods

from :: Bool -> Rep Bool x Source #

to :: Rep Bool x -> Bool Source #

Generic Ordering 

Associated Types

type Rep Ordering :: * -> * Source #

Generic () 

Associated Types

type Rep () :: * -> * Source #

Methods

from :: () -> Rep () x Source #

to :: Rep () x -> () Source #

Generic Void 

Associated Types

type Rep Void :: * -> * Source #

Methods

from :: Void -> Rep Void x Source #

to :: Rep Void x -> Void Source #

Generic Version 

Associated Types

type Rep Version :: * -> * Source #

Generic ExitCode 

Associated Types

type Rep ExitCode :: * -> * Source #

Generic All 

Associated Types

type Rep All :: * -> * Source #

Methods

from :: All -> Rep All x Source #

to :: Rep All x -> All Source #

Generic Any 

Associated Types

type Rep Any :: * -> * Source #

Methods

from :: Any -> Rep Any x Source #

to :: Rep Any x -> Any Source #

Generic Fixity 

Associated Types

type Rep Fixity :: * -> * Source #

Generic Associativity 
Generic SourceUnpackedness 
Generic SourceStrictness 
Generic DecidedStrictness 
Generic Doc 

Associated Types

type Rep Doc :: * -> * Source #

Methods

from :: Doc -> Rep Doc x Source #

to :: Rep Doc x -> Doc Source #

Generic TextDetails 

Associated Types

type Rep TextDetails :: * -> * Source #

Generic Style 

Associated Types

type Rep Style :: * -> * Source #

Methods

from :: Style -> Rep Style x Source #

to :: Rep Style x -> Style Source #

Generic Mode 

Associated Types

type Rep Mode :: * -> * Source #

Methods

from :: Mode -> Rep Mode x Source #

to :: Rep Mode x -> Mode Source #

Generic Platform # 

Associated Types

type Rep Platform :: * -> * Source #

Generic Arch # 

Associated Types

type Rep Arch :: * -> * Source #

Methods

from :: Arch -> Rep Arch x Source #

to :: Rep Arch x -> Arch Source #

Generic OS # 

Associated Types

type Rep OS :: * -> * Source #

Methods

from :: OS -> Rep OS x Source #

to :: Rep OS x -> OS Source #

Generic BuildType # 

Associated Types

type Rep BuildType :: * -> * Source #

Generic ExecutableScope # 
Generic ForeignLibOption # 
Generic ForeignLibType # 
Generic RepoType # 

Associated Types

type Rep RepoType :: * -> * Source #

Generic RepoKind # 

Associated Types

type Rep RepoKind :: * -> * Source #

Generic SourceRepo # 

Associated Types

type Rep SourceRepo :: * -> * Source #

Generic ShortText # 

Associated Types

type Rep ShortText :: * -> * Source #

Generic PkgconfigName # 
Generic ComponentId # 

Associated Types

type Rep ComponentId :: * -> * Source #

Generic AbiHash # 

Associated Types

type Rep AbiHash :: * -> * Source #

Generic ModuleName # 

Associated Types

type Rep ModuleName :: * -> * Source #

Generic ModuleRenaming # 
Generic IncludeRenaming # 
Generic Verbosity # 

Associated Types

type Rep Verbosity :: * -> * Source #

Generic VersionRange # 

Associated Types

type Rep VersionRange :: * -> * Source #

Generic Version # 

Associated Types

type Rep Version :: * -> * Source #

Generic TestType # 

Associated Types

type Rep TestType :: * -> * Source #

Generic TestSuiteInterface # 
Generic PkgconfigDependency # 
Generic BenchmarkType # 
Generic BenchmarkInterface # 
Generic License # 

Associated Types

type Rep License :: * -> * Source #

Generic KnownExtension # 
Generic Extension # 

Associated Types

type Rep Extension :: * -> * Source #

Generic Language # 

Associated Types

type Rep Language :: * -> * Source #

Generic AbiTag # 

Associated Types

type Rep AbiTag :: * -> * Source #

Generic CompilerInfo # 

Associated Types

type Rep CompilerInfo :: * -> * Source #

Generic CompilerId # 

Associated Types

type Rep CompilerId :: * -> * Source #

Generic CompilerFlavor # 
Generic PackageName # 

Associated Types

type Rep PackageName :: * -> * Source #

Generic UnqualComponentName # 
Generic ComponentName # 
Generic PackageIdentifier # 
Generic DefUnitId # 

Associated Types

type Rep DefUnitId :: * -> * Source #

Generic UnitId # 

Associated Types

type Rep UnitId :: * -> * Source #

Generic Module # 

Associated Types

type Rep Module :: * -> * Source #

Generic OpenModule # 

Associated Types

type Rep OpenModule :: * -> * Source #

Generic OpenUnitId # 

Associated Types

type Rep OpenUnitId :: * -> * Source #

Generic FullUnitId # 

Associated Types

type Rep FullUnitId :: * -> * Source #

Generic ModuleReexport # 
Generic Mixin # 

Associated Types

type Rep Mixin :: * -> * Source #

Methods

from :: Mixin -> Rep Mixin x Source #

to :: Rep Mixin x -> Mixin Source #

Generic ExeDependency # 
Generic Dependency # 

Associated Types

type Rep Dependency :: * -> * Source #

Generic SetupBuildInfo # 
Generic MungedPackageName # 
Generic MungedPackageId # 
Generic PathTemplateVariable # 
Generic PathTemplate # 

Associated Types

type Rep PathTemplate :: * -> * Source #

Generic LegacyExeDependency # 
Generic BuildInfo # 

Associated Types

type Rep BuildInfo :: * -> * Source #

Generic TestSuite # 

Associated Types

type Rep TestSuite :: * -> * Source #

Generic Library # 

Associated Types

type Rep Library :: * -> * Source #

Generic LibVersionInfo # 
Generic ForeignLib # 

Associated Types

type Rep ForeignLib :: * -> * Source #

Generic Executable # 

Associated Types

type Rep Executable :: * -> * Source #

Generic Benchmark # 

Associated Types

type Rep Benchmark :: * -> * Source #

Generic ComponentRequestedSpec # 
Generic PackageDescription # 
Generic ConfVar # 

Associated Types

type Rep ConfVar :: * -> * Source #

Generic FlagName # 

Associated Types

type Rep FlagName :: * -> * Source #

Generic Flag # 

Associated Types

type Rep Flag :: * -> * Source #

Methods

from :: Flag -> Rep Flag x Source #

to :: Rep Flag x -> Flag Source #

Generic GenericPackageDescription # 
Generic AbiDependency # 
Generic ExposedModule # 
Generic InstalledPackageInfo # 
Generic ComponentLocalBuildInfo # 
Generic ModuleShape # 

Associated Types

type Rep ModuleShape :: * -> * Source #

Generic ProgramSearchPathEntry # 
Generic ProgramLocation # 
Generic ConfiguredProgram # 
Generic ProfDetailLevel # 
Generic DebugInfoLevel # 
Generic OptimisationLevel # 
Generic PackageDB # 

Associated Types

type Rep PackageDB :: * -> * Source #

Generic Compiler # 

Associated Types

type Rep Compiler :: * -> * Source #

Generic BenchmarkFlags # 
Generic TestFlags # 

Associated Types

type Rep TestFlags :: * -> * Source #

Generic ReplFlags # 

Associated Types

type Rep ReplFlags :: * -> * Source #

Generic BuildFlags # 

Associated Types

type Rep BuildFlags :: * -> * Source #

Generic CleanFlags # 

Associated Types

type Rep CleanFlags :: * -> * Source #

Generic HaddockFlags # 

Associated Types

type Rep HaddockFlags :: * -> * Source #

Generic HaddockTarget # 
Generic DoctestFlags # 

Associated Types

type Rep DoctestFlags :: * -> * Source #

Generic HscolourFlags # 
Generic RegisterFlags # 
Generic SDistFlags # 

Associated Types

type Rep SDistFlags :: * -> * Source #

Generic InstallFlags # 

Associated Types

type Rep InstallFlags :: * -> * Source #

Generic CopyFlags # 

Associated Types

type Rep CopyFlags :: * -> * Source #

Generic ConfigFlags # 

Associated Types

type Rep ConfigFlags :: * -> * Source #

Generic RelaxedDep # 

Associated Types

type Rep RelaxedDep :: * -> * Source #

Generic AllowOlder # 

Associated Types

type Rep AllowOlder :: * -> * Source #

Generic AllowNewer # 

Associated Types

type Rep AllowNewer :: * -> * Source #

Generic RelaxDeps # 

Associated Types

type Rep RelaxDeps :: * -> * Source #

Generic GlobalFlags # 

Associated Types

type Rep GlobalFlags :: * -> * Source #

Generic LocalBuildInfo # 
Generic GhcOptions # 

Associated Types

type Rep GhcOptions :: * -> * Source #

Generic BuildTarget # 

Associated Types

type Rep BuildTarget :: * -> * Source #

Generic [a] 

Associated Types

type Rep [a] :: * -> * Source #

Methods

from :: [a] -> Rep [a] x Source #

to :: Rep [a] x -> [a] Source #

Generic (Maybe a) 

Associated Types

type Rep (Maybe a) :: * -> * Source #

Methods

from :: Maybe a -> Rep (Maybe a) x Source #

to :: Rep (Maybe a) x -> Maybe a Source #

Generic (Par1 p) 

Associated Types

type Rep (Par1 p) :: * -> * Source #

Methods

from :: Par1 p -> Rep (Par1 p) x Source #

to :: Rep (Par1 p) x -> Par1 p Source #

Generic (Complex a) 

Associated Types

type Rep (Complex a) :: * -> * Source #

Methods

from :: Complex a -> Rep (Complex a) x Source #

to :: Rep (Complex a) x -> Complex a Source #

Generic (Min a) 

Associated Types

type Rep (Min a) :: * -> * Source #

Methods

from :: Min a -> Rep (Min a) x Source #

to :: Rep (Min a) x -> Min a Source #

Generic (Max a) 

Associated Types

type Rep (Max a) :: * -> * Source #

Methods

from :: Max a -> Rep (Max a) x Source #

to :: Rep (Max a) x -> Max a Source #

Generic (First a) 

Associated Types

type Rep (First a) :: * -> * Source #

Methods

from :: First a -> Rep (First a) x Source #

to :: Rep (First a) x -> First a Source #

Generic (Last a) 

Associated Types

type Rep (Last a) :: * -> * Source #

Methods

from :: Last a -> Rep (Last a) x Source #

to :: Rep (Last a) x -> Last a Source #

Generic (WrappedMonoid m) 

Associated Types

type Rep (WrappedMonoid m) :: * -> * Source #

Generic (Option a) 

Associated Types

type Rep (Option a) :: * -> * Source #

Methods

from :: Option a -> Rep (Option a) x Source #

to :: Rep (Option a) x -> Option a Source #

Generic (NonEmpty a) 

Associated Types

type Rep (NonEmpty a) :: * -> * Source #

Methods

from :: NonEmpty a -> Rep (NonEmpty a) x Source #

to :: Rep (NonEmpty a) x -> NonEmpty a Source #

Generic (ZipList a) 

Associated Types

type Rep (ZipList a) :: * -> * Source #

Methods

from :: ZipList a -> Rep (ZipList a) x Source #

to :: Rep (ZipList a) x -> ZipList a Source #

Generic (Identity a) 

Associated Types

type Rep (Identity a) :: * -> * Source #

Methods

from :: Identity a -> Rep (Identity a) x Source #

to :: Rep (Identity a) x -> Identity a Source #

Generic (Dual a) 

Associated Types

type Rep (Dual a) :: * -> * Source #

Methods

from :: Dual a -> Rep (Dual a) x Source #

to :: Rep (Dual a) x -> Dual a Source #

Generic (Endo a) 

Associated Types

type Rep (Endo a) :: * -> * Source #

Methods

from :: Endo a -> Rep (Endo a) x Source #

to :: Rep (Endo a) x -> Endo a Source #

Generic (Sum a) 

Associated Types

type Rep (Sum a) :: * -> * Source #

Methods

from :: Sum a -> Rep (Sum a) x Source #

to :: Rep (Sum a) x -> Sum a Source #

Generic (Product a) 

Associated Types

type Rep (Product a) :: * -> * Source #

Methods

from :: Product a -> Rep (Product a) x Source #

to :: Rep (Product a) x -> Product a Source #

Generic (First a) 

Associated Types

type Rep (First a) :: * -> * Source #

Methods

from :: First a -> Rep (First a) x Source #

to :: Rep (First a) x -> First a Source #

Generic (Last a) 

Associated Types

type Rep (Last a) :: * -> * Source #

Methods

from :: Last a -> Rep (Last a) x Source #

to :: Rep (Last a) x -> Last a Source #

Generic (SCC vertex) 

Associated Types

type Rep (SCC vertex) :: * -> * Source #

Methods

from :: SCC vertex -> Rep (SCC vertex) x Source #

to :: Rep (SCC vertex) x -> SCC vertex Source #

Generic (Tree a) 

Associated Types

type Rep (Tree a) :: * -> * Source #

Methods

from :: Tree a -> Rep (Tree a) x Source #

to :: Rep (Tree a) x -> Tree a Source #

Generic (ViewL a) 

Associated Types

type Rep (ViewL a) :: * -> * Source #

Methods

from :: ViewL a -> Rep (ViewL a) x Source #

to :: Rep (ViewL a) x -> ViewL a Source #

Generic (ViewR a) 

Associated Types

type Rep (ViewR a) :: * -> * Source #

Methods

from :: ViewR a -> Rep (ViewR a) x Source #

to :: Rep (ViewR a) x -> ViewR a Source #

Generic (Doc a) 

Associated Types

type Rep (Doc a) :: * -> * Source #

Methods

from :: Doc a -> Rep (Doc a) x Source #

to :: Rep (Doc a) x -> Doc a Source #

Generic (Last' a) # 

Associated Types

type Rep (Last' a) :: * -> * Source #

Methods

from :: Last' a -> Rep (Last' a) x Source #

to :: Rep (Last' a) x -> Last' a Source #

Generic (Condition c) # 

Associated Types

type Rep (Condition c) :: * -> * Source #

Methods

from :: Condition c -> Rep (Condition c) x Source #

to :: Rep (Condition c) x -> Condition c Source #

Generic (InstallDirs dir) # 

Associated Types

type Rep (InstallDirs dir) :: * -> * Source #

Methods

from :: InstallDirs dir -> Rep (InstallDirs dir) x Source #

to :: Rep (InstallDirs dir) x -> InstallDirs dir Source #

Generic (PackageIndex a) # 

Associated Types

type Rep (PackageIndex a) :: * -> * Source #

Generic (Flag a) # 

Associated Types

type Rep (Flag a) :: * -> * Source #

Methods

from :: Flag a -> Rep (Flag a) x Source #

to :: Rep (Flag a) x -> Flag a Source #

Generic (Either a b) 

Associated Types

type Rep (Either a b) :: * -> * Source #

Methods

from :: Either a b -> Rep (Either a b) x Source #

to :: Rep (Either a b) x -> Either a b Source #

Generic (V1 k p) 

Associated Types

type Rep (V1 k p) :: * -> * Source #

Methods

from :: V1 k p -> Rep (V1 k p) x Source #

to :: Rep (V1 k p) x -> V1 k p Source #

Generic (U1 k p) 

Associated Types

type Rep (U1 k p) :: * -> * Source #

Methods

from :: U1 k p -> Rep (U1 k p) x Source #

to :: Rep (U1 k p) x -> U1 k p Source #

Generic (a, b) 

Associated Types

type Rep (a, b) :: * -> * Source #

Methods

from :: (a, b) -> Rep (a, b) x Source #

to :: Rep (a, b) x -> (a, b) Source #

Generic (Arg a b) 

Associated Types

type Rep (Arg a b) :: * -> * Source #

Methods

from :: Arg a b -> Rep (Arg a b) x Source #

to :: Rep (Arg a b) x -> Arg a b Source #

Generic (WrappedMonad m a) 

Associated Types

type Rep (WrappedMonad m a) :: * -> * Source #

Methods

from :: WrappedMonad m a -> Rep (WrappedMonad m a) x Source #

to :: Rep (WrappedMonad m a) x -> WrappedMonad m a Source #

Generic (Proxy k t) 

Associated Types

type Rep (Proxy k t) :: * -> * Source #

Methods

from :: Proxy k t -> Rep (Proxy k t) x Source #

to :: Rep (Proxy k t) x -> Proxy k t Source #

Generic (Rec1 k f p) 

Associated Types

type Rep (Rec1 k f p) :: * -> * Source #

Methods

from :: Rec1 k f p -> Rep (Rec1 k f p) x Source #

to :: Rep (Rec1 k f p) x -> Rec1 k f p Source #

Generic (URec k (Ptr ()) p) 

Associated Types

type Rep (URec k (Ptr ()) p) :: * -> * Source #

Methods

from :: URec k (Ptr ()) p -> Rep (URec k (Ptr ()) p) x Source #

to :: Rep (URec k (Ptr ()) p) x -> URec k (Ptr ()) p Source #

Generic (URec k Char p) 

Associated Types

type Rep (URec k Char p) :: * -> * Source #

Methods

from :: URec k Char p -> Rep (URec k Char p) x Source #

to :: Rep (URec k Char p) x -> URec k Char p Source #

Generic (URec k Double p) 

Associated Types

type Rep (URec k Double p) :: * -> * Source #

Methods

from :: URec k Double p -> Rep (URec k Double p) x Source #

to :: Rep (URec k Double p) x -> URec k Double p Source #

Generic (URec k Float p) 

Associated Types

type Rep (URec k Float p) :: * -> * Source #

Methods

from :: URec k Float p -> Rep (URec k Float p) x Source #

to :: Rep (URec k Float p) x -> URec k Float p Source #

Generic (URec k Int p) 

Associated Types

type Rep (URec k Int p) :: * -> * Source #

Methods

from :: URec k Int p -> Rep (URec k Int p) x Source #

to :: Rep (URec k Int p) x -> URec k Int p Source #

Generic (URec k Word p) 

Associated Types

type Rep (URec k Word p) :: * -> * Source #

Methods

from :: URec k Word p -> Rep (URec k Word p) x Source #

to :: Rep (URec k Word p) x -> URec k Word p Source #

Generic (a, b, c) 

Associated Types

type Rep (a, b, c) :: * -> * Source #

Methods

from :: (a, b, c) -> Rep (a, b, c) x Source #

to :: Rep (a, b, c) x -> (a, b, c) Source #

Generic (WrappedArrow a b c) 

Associated Types

type Rep (WrappedArrow a b c) :: * -> * Source #

Methods

from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x Source #

to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c Source #

Generic (Const k a b) 

Associated Types

type Rep (Const k a b) :: * -> * Source #

Methods

from :: Const k a b -> Rep (Const k a b) x Source #

to :: Rep (Const k a b) x -> Const k a b Source #

Generic (Alt k f a) 

Associated Types

type Rep (Alt k f a) :: * -> * Source #

Methods

from :: Alt k f a -> Rep (Alt k f a) x Source #

to :: Rep (Alt k f a) x -> Alt k f a Source #

Generic (CondBranch v c a) # 

Associated Types

type Rep (CondBranch v c a) :: * -> * Source #

Methods

from :: CondBranch v c a -> Rep (CondBranch v c a) x Source #

to :: Rep (CondBranch v c a) x -> CondBranch v c a Source #

Generic (CondTree v c a) # 

Associated Types

type Rep (CondTree v c a) :: * -> * Source #

Methods

from :: CondTree v c a -> Rep (CondTree v c a) x Source #

to :: Rep (CondTree v c a) x -> CondTree v c a Source #

Generic (K1 k i c p) 

Associated Types

type Rep (K1 k i c p) :: * -> * Source #

Methods

from :: K1 k i c p -> Rep (K1 k i c p) x Source #

to :: Rep (K1 k i c p) x -> K1 k i c p Source #

Generic ((:+:) k f g p) 

Associated Types

type Rep ((k :+: f) g p) :: * -> * Source #

Methods

from :: (k :+: f) g p -> Rep ((k :+: f) g p) x Source #

to :: Rep ((k :+: f) g p) x -> (k :+: f) g p Source #

Generic ((:*:) k f g p) 

Associated Types

type Rep ((k :*: f) g p) :: * -> * Source #

Methods

from :: (k :*: f) g p -> Rep ((k :*: f) g p) x Source #

to :: Rep ((k :*: f) g p) x -> (k :*: f) g p Source #

Generic (a, b, c, d) 

Associated Types

type Rep (a, b, c, d) :: * -> * Source #

Methods

from :: (a, b, c, d) -> Rep (a, b, c, d) x Source #

to :: Rep (a, b, c, d) x -> (a, b, c, d) Source #

Generic (Product k f g a) 

Associated Types

type Rep (Product k f g a) :: * -> * Source #

Methods

from :: Product k f g a -> Rep (Product k f g a) x Source #

to :: Rep (Product k f g a) x -> Product k f g a Source #

Generic (Sum k f g a) 

Associated Types

type Rep (Sum k f g a) :: * -> * Source #

Methods

from :: Sum k f g a -> Rep (Sum k f g a) x Source #

to :: Rep (Sum k f g a) x -> Sum k f g a Source #

Generic (M1 k i c f p) 

Associated Types

type Rep (M1 k i c f p) :: * -> * Source #

Methods

from :: M1 k i c f p -> Rep (M1 k i c f p) x Source #

to :: Rep (M1 k i c f p) x -> M1 k i c f p Source #

Generic ((:.:) k2 k1 f g p) 

Associated Types

type Rep ((k2 :.: k1) f g p) :: * -> * Source #

Methods

from :: (k2 :.: k1) f g p -> Rep ((k2 :.: k1) f g p) x Source #

to :: Rep ((k2 :.: k1) f g p) x -> (k2 :.: k1) f g p Source #

Generic (a, b, c, d, e) 

Associated Types

type Rep (a, b, c, d, e) :: * -> * Source #

Methods

from :: (a, b, c, d, e) -> Rep (a, b, c, d, e) x Source #

to :: Rep (a, b, c, d, e) x -> (a, b, c, d, e) Source #

Generic (Compose k1 k2 f g a) 

Associated Types

type Rep (Compose k1 k2 f g a) :: * -> * Source #

Methods

from :: Compose k1 k2 f g a -> Rep (Compose k1 k2 f g a) x Source #

to :: Rep (Compose k1 k2 f g a) x -> Compose k1 k2 f g a Source #

Generic (a, b, c, d, e, f) 

Associated Types

type Rep (a, b, c, d, e, f) :: * -> * Source #

Methods

from :: (a, b, c, d, e, f) -> Rep (a, b, c, d, e, f) x Source #

to :: Rep (a, b, c, d, e, f) x -> (a, b, c, d, e, f) Source #

Generic (a, b, c, d, e, f, g) 

Associated Types

type Rep (a, b, c, d, e, f, g) :: * -> * Source #

Methods

from :: (a, b, c, d, e, f, g) -> Rep (a, b, c, d, e, f, g) x Source #

to :: Rep (a, b, c, d, e, f, g) x -> (a, b, c, d, e, f, g) Source #

class NFData a where Source #

A class of types that can be fully evaluated.

Since: 1.1.0.0

Methods

rnf :: a -> () Source #

rnf should reduce its argument to normal form (that is, fully evaluate all sub-components), and then return '()'.

Generic NFData deriving

Starting with GHC 7.2, you can automatically derive instances for types possessing a Generic instance.

Note: Generic1 can be auto-derived starting with GHC 7.4

{-# LANGUAGE DeriveGeneric #-}

import GHC.Generics (Generic, Generic1)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic, Generic1)

instance NFData a => NFData (Foo a)
instance NFData1 Foo

data Colour = Red | Green | Blue
              deriving Generic

instance NFData Colour

Starting with GHC 7.10, the example above can be written more concisely by enabling the new DeriveAnyClass extension:

{-# LANGUAGE DeriveGeneric, DeriveAnyClass #-}

import GHC.Generics (Generic)
import Control.DeepSeq

data Foo a = Foo a String
             deriving (Eq, Generic, Generic1, NFData, NFData1)

data Colour = Red | Green | Blue
              deriving (Generic, NFData)

Compatibility with previous deepseq versions

Prior to version 1.4.0.0, the default implementation of the rnf method was defined as

rnf a = seq a ()

However, starting with deepseq-1.4.0.0, the default implementation is based on DefaultSignatures allowing for more accurate auto-derived NFData instances. If you need the previously used exact default rnf method implementation semantics, use

instance NFData Colour where rnf x = seq x ()

or alternatively

instance NFData Colour where rnf = rwhnf

or

{-# LANGUAGE BangPatterns #-}
instance NFData Colour where rnf !_ = ()

Instances

NFData Bool 

Methods

rnf :: Bool -> () Source #

NFData Char 

Methods

rnf :: Char -> () Source #

NFData Double 

Methods

rnf :: Double -> () Source #

NFData Float 

Methods

rnf :: Float -> () Source #

NFData Int 

Methods

rnf :: Int -> () Source #

NFData Int8 

Methods

rnf :: Int8 -> () Source #

NFData Int16 

Methods

rnf :: Int16 -> () Source #

NFData Int32 

Methods

rnf :: Int32 -> () Source #

NFData Int64 

Methods

rnf :: Int64 -> () Source #

NFData Integer 

Methods

rnf :: Integer -> () Source #

NFData Natural

Since: 1.4.0.0

Methods

rnf :: Natural -> () Source #

NFData Ordering 

Methods

rnf :: Ordering -> () Source #

NFData Word 

Methods

rnf :: Word -> () Source #

NFData Word8 

Methods

rnf :: Word8 -> () Source #

NFData Word16 

Methods

rnf :: Word16 -> () Source #

NFData Word32 

Methods

rnf :: Word32 -> () Source #

NFData Word64 

Methods

rnf :: Word64 -> () Source #

NFData CallStack

Since: 1.4.2.0

Methods

rnf :: CallStack -> () Source #

NFData () 

Methods

rnf :: () -> () Source #

NFData TyCon

NOTE: Only defined for base-4.8.0.0 and later

Since: 1.4.0.0

Methods

rnf :: TyCon -> () Source #

NFData Void

Defined as rnf = absurd.

Since: 1.4.0.0

Methods

rnf :: Void -> () Source #

NFData Unique

Since: 1.4.0.0

Methods

rnf :: Unique -> () Source #

NFData Version

Since: 1.3.0.0

Methods

rnf :: Version -> () Source #

NFData ThreadId

Since: 1.4.0.0

Methods

rnf :: ThreadId -> () Source #

NFData ExitCode

Since: 1.4.2.0

Methods

rnf :: ExitCode -> () Source #

NFData TypeRep

NOTE: Only defined for base-4.8.0.0 and later

Since: 1.4.0.0

Methods

rnf :: TypeRep -> () Source #

NFData All

Since: 1.4.0.0

Methods

rnf :: All -> () Source #

NFData Any

Since: 1.4.0.0

Methods

rnf :: Any -> () Source #

NFData CChar

Since: 1.4.0.0

Methods

rnf :: CChar -> () Source #

NFData CSChar

Since: 1.4.0.0

Methods

rnf :: CSChar -> () Source #

NFData CUChar

Since: 1.4.0.0

Methods

rnf :: CUChar -> () Source #

NFData CShort

Since: 1.4.0.0

Methods

rnf :: CShort -> () Source #

NFData CUShort

Since: 1.4.0.0

Methods

rnf :: CUShort -> () Source #

NFData CInt

Since: 1.4.0.0

Methods

rnf :: CInt -> () Source #

NFData CUInt

Since: 1.4.0.0

Methods

rnf :: CUInt -> () Source #

NFData CLong

Since: 1.4.0.0

Methods

rnf :: CLong -> () Source #

NFData CULong

Since: 1.4.0.0

Methods

rnf :: CULong -> () Source #

NFData CLLong

Since: 1.4.0.0

Methods

rnf :: CLLong -> () Source #

NFData CULLong

Since: 1.4.0.0

Methods

rnf :: CULLong -> () Source #

NFData CBool

Since: 1.4.3.0

Methods

rnf :: CBool -> () Source #

NFData CFloat

Since: 1.4.0.0

Methods

rnf :: CFloat -> () Source #

NFData CDouble

Since: 1.4.0.0

Methods

rnf :: CDouble -> () Source #

NFData CPtrdiff

Since: 1.4.0.0

Methods

rnf :: CPtrdiff -> () Source #

NFData CSize

Since: 1.4.0.0

Methods

rnf :: CSize -> () Source #

NFData CWchar

Since: 1.4.0.0

Methods

rnf :: CWchar -> () Source #

NFData CSigAtomic

Since: 1.4.0.0

Methods

rnf :: CSigAtomic -> () Source #

NFData CClock

Since: 1.4.0.0

Methods

rnf :: CClock -> () Source #

NFData CTime

Since: 1.4.0.0

Methods

rnf :: CTime -> () Source #

NFData CUSeconds

Since: 1.4.0.0

Methods

rnf :: CUSeconds -> () Source #

NFData CSUSeconds

Since: 1.4.0.0

Methods

rnf :: CSUSeconds -> () Source #

NFData CFile

Since: 1.4.0.0

Methods

rnf :: CFile -> () Source #

NFData CFpos

Since: 1.4.0.0

Methods

rnf :: CFpos -> () Source #

NFData CJmpBuf

Since: 1.4.0.0

Methods

rnf :: CJmpBuf -> () Source #

NFData CIntPtr

Since: 1.4.0.0

Methods

rnf :: CIntPtr -> () Source #

NFData CUIntPtr

Since: 1.4.0.0

Methods

rnf :: CUIntPtr -> () Source #

NFData CIntMax

Since: 1.4.0.0

Methods

rnf :: CIntMax -> () Source #

NFData CUIntMax

Since: 1.4.0.0

Methods

rnf :: CUIntMax -> () Source #

NFData Fingerprint

Since: 1.4.0.0

Methods

rnf :: Fingerprint -> () Source #

NFData SrcLoc

Since: 1.4.2.0

Methods

rnf :: SrcLoc -> () Source #

NFData ByteString 

Methods

rnf :: ByteString -> () Source #

NFData ShortByteString 

Methods

rnf :: ShortByteString -> () Source #

NFData ByteString 

Methods

rnf :: ByteString -> () Source #

NFData IntSet 

Methods

rnf :: IntSet -> () Source #

NFData Doc 

Methods

rnf :: Doc -> () Source #

NFData TextDetails 

Methods

rnf :: TextDetails -> () Source #

NFData ZonedTime 

Methods

rnf :: ZonedTime -> () Source #

NFData LocalTime 

Methods

rnf :: LocalTime -> () Source #

NFData TimeOfDay 

Methods

rnf :: TimeOfDay -> () Source #

NFData TimeZone 

Methods

rnf :: TimeZone -> () Source #

NFData UniversalTime 

Methods

rnf :: UniversalTime -> () Source #

NFData UTCTime 

Methods

rnf :: UTCTime -> () Source #

NFData NominalDiffTime 

Methods

rnf :: NominalDiffTime -> () Source #

NFData Day 

Methods

rnf :: Day -> () Source #

NFData ShortText # 

Methods

rnf :: ShortText -> () Source #

NFData PkgconfigName # 

Methods

rnf :: PkgconfigName -> () Source #

NFData ComponentId # 

Methods

rnf :: ComponentId -> () Source #

NFData ModuleName # 

Methods

rnf :: ModuleName -> () Source #

NFData VersionRange # 

Methods

rnf :: VersionRange -> () Source #

NFData Version # 

Methods

rnf :: Version -> () Source #

NFData PkgconfigDependency # 
NFData PackageName # 

Methods

rnf :: PackageName -> () Source #

NFData UnqualComponentName # 
NFData PackageIdentifier # 

Methods

rnf :: PackageIdentifier -> () Source #

NFData DefUnitId # 

Methods

rnf :: DefUnitId -> () Source #

NFData UnitId # 

Methods

rnf :: UnitId -> () Source #

NFData Module # 

Methods

rnf :: Module -> () Source #

NFData OpenModule # 

Methods

rnf :: OpenModule -> () Source #

NFData OpenUnitId # 

Methods

rnf :: OpenUnitId -> () Source #

NFData ExeDependency # 

Methods

rnf :: ExeDependency -> () Source #

NFData Dependency # 

Methods

rnf :: Dependency -> () Source #

NFData MungedPackageName # 

Methods

rnf :: MungedPackageName -> () Source #

NFData MungedPackageId # 

Methods

rnf :: MungedPackageId -> () Source #

NFData LegacyExeDependency # 
NFData a => NFData [a] 

Methods

rnf :: [a] -> () Source #

NFData a => NFData (Maybe a) 

Methods

rnf :: Maybe a -> () Source #

NFData a => NFData (Ratio a) 

Methods

rnf :: Ratio a -> () Source #

NFData (Ptr a)

Since: 1.4.2.0

Methods

rnf :: Ptr a -> () Source #

NFData (FunPtr a)

Since: 1.4.2.0

Methods

rnf :: FunPtr a -> () Source #

NFData a => NFData (Complex a) 

Methods

rnf :: Complex a -> () Source #

NFData (Fixed a)

Since: 1.3.0.0

Methods

rnf :: Fixed a -> () Source #

NFData a => NFData (Min a)

Since: 1.4.2.0

Methods

rnf :: Min a -> () Source #

NFData a => NFData (Max a)

Since: 1.4.2.0

Methods

rnf :: Max a -> () Source #

NFData a => NFData (First a)

Since: 1.4.2.0

Methods

rnf :: First a -> () Source #

NFData a => NFData (Last a)

Since: 1.4.2.0

Methods

rnf :: Last a -> () Source #

NFData m => NFData (WrappedMonoid m)

Since: 1.4.2.0

Methods

rnf :: WrappedMonoid m -> () Source #

NFData a => NFData (Option a)

Since: 1.4.2.0

Methods

rnf :: Option a -> () Source #

NFData a => NFData (NonEmpty a)

Since: 1.4.2.0

Methods

rnf :: NonEmpty a -> () Source #

NFData (StableName a)

Since: 1.4.0.0

Methods

rnf :: StableName a -> () Source #

NFData a => NFData (ZipList a)

Since: 1.4.0.0

Methods

rnf :: ZipList a -> () Source #

NFData a => NFData (Identity a)

Since: 1.4.0.0

Methods

rnf :: Identity a -> () Source #

NFData (IORef a)

NOTE: Only strict in the reference and not the referenced value.

Since: 1.4.2.0

Methods

rnf :: IORef a -> () Source #

NFData a => NFData (Dual a)

Since: 1.4.0.0

Methods

rnf :: Dual a -> () Source #

NFData a => NFData (Sum a)

Since: 1.4.0.0

Methods

rnf :: Sum a -> () Source #

NFData a => NFData (Product a)

Since: 1.4.0.0

Methods

rnf :: Product a -> () Source #

NFData a => NFData (First a)

Since: 1.4.0.0

Methods

rnf :: First a -> () Source #

NFData a => NFData (Last a)

Since: 1.4.0.0

Methods

rnf :: Last a -> () Source #

NFData a => NFData (Down a)

Since: 1.4.0.0

Methods

rnf :: Down a -> () Source #

NFData (MVar a)

NOTE: Only strict in the reference and not the referenced value.

Since: 1.4.2.0

Methods

rnf :: MVar a -> () Source #

NFData a => NFData (IntMap a) 

Methods

rnf :: IntMap a -> () Source #

NFData a => NFData (SCC a) 

Methods

rnf :: SCC a -> () Source #

NFData a => NFData (Tree a) 

Methods

rnf :: Tree a -> () Source #

NFData a => NFData (Seq a) 

Methods

rnf :: Seq a -> () Source #

NFData a => NFData (FingerTree a) 

Methods

rnf :: FingerTree a -> () Source #

NFData a => NFData (Digit a) 

Methods

rnf :: Digit a -> () Source #

NFData a => NFData (Node a) 

Methods

rnf :: Node a -> () Source #

NFData a => NFData (Elem a) 

Methods

rnf :: Elem a -> () Source #

NFData a => NFData (Set a) 

Methods

rnf :: Set a -> () Source #

NFData a => NFData (Doc a) 

Methods

rnf :: Doc a -> () Source #

NFData a => NFData (AnnotDetails a) 

Methods

rnf :: AnnotDetails a -> () Source #

(NFData a, NFData (Key a)) => NFData (Graph a) # 

Methods

rnf :: Graph a -> () Source #

NFData (a -> b)

This instance is for convenience and consistency with seq. This assumes that WHNF is equivalent to NF for functions.

Since: 1.3.0.0

Methods

rnf :: (a -> b) -> () Source #

(NFData a, NFData b) => NFData (Either a b) 

Methods

rnf :: Either a b -> () Source #

(NFData a, NFData b) => NFData (a, b) 

Methods

rnf :: (a, b) -> () Source #

(NFData a, NFData b) => NFData (Array a b) 

Methods

rnf :: Array a b -> () Source #

(NFData a, NFData b) => NFData (Arg a b)

Since: 1.4.2.0

Methods

rnf :: Arg a b -> () Source #

NFData (Proxy k a)

Since: 1.4.0.0

Methods

rnf :: Proxy k a -> () Source #

NFData (STRef s a)

NOTE: Only strict in the reference and not the referenced value.

Since: 1.4.2.0

Methods

rnf :: STRef s a -> () Source #

(NFData k, NFData a) => NFData (Map k a) 

Methods

rnf :: Map k a -> () Source #

(NFData a1, NFData a2, NFData a3) => NFData (a1, a2, a3) 

Methods

rnf :: (a1, a2, a3) -> () Source #

NFData a => NFData (Const k a b)

Since: 1.4.0.0

Methods

rnf :: Const k a b -> () Source #

NFData ((:~:) k a b)

Since: 1.4.3.0

Methods

rnf :: (k :~: a) b -> () Source #

(NFData a1, NFData a2, NFData a3, NFData a4) => NFData (a1, a2, a3, a4) 

Methods

rnf :: (a1, a2, a3, a4) -> () Source #

(NFData1 f, NFData1 g, NFData a) => NFData (Product * f g a)

Since: 1.4.3.0

Methods

rnf :: Product * f g a -> () Source #

(NFData1 f, NFData1 g, NFData a) => NFData (Sum * f g a)

Since: 1.4.3.0

Methods

rnf :: Sum * f g a -> () Source #

NFData ((:~~:) k1 k2 a b)

Since: 1.4.3.0

Methods

rnf :: (k1 :~~: k2) a b -> () Source #

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5) => NFData (a1, a2, a3, a4, a5) 

Methods

rnf :: (a1, a2, a3, a4, a5) -> () Source #

(NFData1 f, NFData1 g, NFData a) => NFData (Compose * * f g a)

Since: 1.4.3.0

Methods

rnf :: Compose * * f g a -> () Source #

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6) => NFData (a1, a2, a3, a4, a5, a6) 

Methods

rnf :: (a1, a2, a3, a4, a5, a6) -> () Source #

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7) => NFData (a1, a2, a3, a4, a5, a6, a7) 

Methods

rnf :: (a1, a2, a3, a4, a5, a6, a7) -> () Source #

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8) => NFData (a1, a2, a3, a4, a5, a6, a7, a8) 

Methods

rnf :: (a1, a2, a3, a4, a5, a6, a7, a8) -> () Source #

(NFData a1, NFData a2, NFData a3, NFData a4, NFData a5, NFData a6, NFData a7, NFData a8, NFData a9) => NFData (a1, a2, a3, a4, a5, a6, a7, a8, a9) 

Methods

rnf :: (a1, a2, a3, a4, a5, a6, a7, a8, a9) -> () Source #

genericRnf :: (Generic a, GNFData (Rep a)) => a -> () Source #

GHC.Generics-based rnf implementation

This is needed in order to support deepseq < 1.4 which didn't have a Generic-based default rnf implementation yet.

In order to define instances, use e.g.

instance NFData MyType where rnf = genericRnf

The implementation has been taken from deepseq-1.4.2's default rnf implementation.

class Binary t where Source #

The Binary class provides put and get, methods to encode and decode a Haskell value to a lazy ByteString. It mirrors the Read and Show classes for textual representation of Haskell types, and is suitable for serialising Haskell values to disk, over the network.

For decoding and generating simple external binary formats (e.g. C structures), Binary may be used, but in general is not suitable for complex protocols. Instead use the Put and Get primitives directly.

Instances of Binary should satisfy the following property:

decode . encode == id

That is, the get and put methods should be the inverse of each other. A range of instances are provided for basic Haskell types.

Methods

put :: t -> Put Source #

Encode a value in the Put monad.

get :: Get t Source #

Decode a value in the Get monad

putList :: [t] -> Put Source #

Encode a list of values in the Put monad. The default implementation may be overridden to be more efficient but must still have the same encoding format.

Instances

Binary Bool 
Binary Char 
Binary Double 
Binary Float 
Binary Int 

Methods

put :: Int -> Put Source #

get :: Get Int Source #

putList :: [Int] -> Put Source #

Binary Int8 
Binary Int16 
Binary Int32 
Binary Int64 
Binary Integer 
Binary Natural

Since: 0.7.3.0

Binary Ordering 
Binary Word 
Binary Word8 
Binary Word16 
Binary Word32 
Binary Word64 
Binary RuntimeRep

@since 0.8.5.0. See

Binary VecCount

@since 0.8.5.0. See

Binary VecElem

@since 0.8.5.0. See

Binary SomeTypeRep 
Binary () 

Methods

put :: () -> Put Source #

get :: Get () Source #

putList :: [()] -> Put Source #

Binary TyCon

@since 0.8.5.0. See

Binary KindRep

@since 0.8.5.0. See

Binary TypeLitSort

@since 0.8.5.0. See

Binary Void

Since: 0.8.0.0

Binary Version

Since: 0.8.0.0

Binary All

Since: 0.8.4.0

Methods

put :: All -> Put Source #

get :: Get All Source #

putList :: [All] -> Put Source #

Binary Any

Since: 0.8.4.0

Methods

put :: Any -> Put Source #

get :: Get Any Source #

putList :: [Any] -> Put Source #

Binary Fingerprint

Since: 0.7.6.0

Binary ByteString 
Binary ShortByteString 
Binary ByteString 
Binary IntSet 
Binary Platform # 
Binary Arch # 
Binary OS # 

Methods

put :: OS -> Put Source #

get :: Get OS Source #

putList :: [OS] -> Put Source #

Binary BuildType # 
Binary ExecutableScope # 
Binary ForeignLibOption # 
Binary ForeignLibType # 
Binary RepoType # 
Binary RepoKind # 
Binary SourceRepo # 
Binary ShortText # 
Binary PkgconfigName # 
Binary ComponentId # 
Binary AbiHash # 
Binary ModuleName # 
Binary ModuleRenaming # 
Binary IncludeRenaming # 
Binary Verbosity # 
Binary VersionRange # 
Binary Version # 
Binary TestType # 
Binary TestSuiteInterface # 
Binary PkgconfigDependency # 
Binary BenchmarkType # 
Binary BenchmarkInterface # 
Binary License # 
Binary KnownExtension # 
Binary Extension # 
Binary Language # 
Binary AbiTag # 
Binary CompilerInfo # 
Binary CompilerId # 
Binary CompilerFlavor # 
Binary PackageName # 
Binary UnqualComponentName # 
Binary ComponentName # 
Binary PackageIdentifier # 
Binary DefUnitId # 
Binary UnitId # 
Binary Module # 
Binary OpenModule # 
Binary OpenUnitId # 
Binary ModuleReexport # 
Binary Mixin # 
Binary ExeDependency # 
Binary Dependency # 
Binary SetupBuildInfo # 
Binary MungedPackageName # 
Binary MungedPackageId # 
Binary PathTemplateVariable # 
Binary PathTemplate # 
Binary LegacyExeDependency # 
Binary BuildInfo # 
Binary TestSuite # 
Binary Library # 
Binary LibVersionInfo # 
Binary ForeignLib # 
Binary Executable # 
Binary Benchmark # 
Binary ComponentRequestedSpec # 
Binary PackageDescription # 
Binary ConfVar # 
Binary FlagName # 
Binary Flag # 
Binary GenericPackageDescription # 
Binary AbiDependency # 
Binary ExposedModule # 
Binary InstalledPackageInfo # 
Binary ComponentLocalBuildInfo # 
Binary ModuleShape # 
Binary ProgramSearchPathEntry # 
Binary ProgramLocation # 
Binary ConfiguredProgram # 
Binary ProgramDb #

Note that this instance does not preserve the known Programs. See restoreProgramDb for details.

Binary ProfDetailLevel # 
Binary DebugInfoLevel # 
Binary OptimisationLevel # 
Binary PackageDB # 
Binary Compiler # 
Binary ConfigFlags # 
Binary RelaxedDep # 
Binary AllowOlder # 
Binary AllowNewer # 
Binary RelaxDeps # 
Binary LocalBuildInfo # 
Binary BuildTarget # 
Binary ModTime # 
Binary a => Binary [a] 

Methods

put :: [a] -> Put Source #

get :: Get [a] Source #

putList :: [[a]] -> Put Source #

Binary a => Binary (Maybe a) 

Methods

put :: Maybe a -> Put Source #

get :: Get (Maybe a) Source #

putList :: [Maybe a] -> Put Source #

(Binary a, Integral a) => Binary (Ratio a) 

Methods

put :: Ratio a -> Put Source #

get :: Get (Ratio a) Source #

putList :: [Ratio a] -> Put Source #

Binary a => Binary (Complex a) 

Methods

put :: Complex a -> Put Source #

get :: Get (Complex a) Source #

putList :: [Complex a] -> Put Source #

Binary (Fixed a)

Since: 0.8.0.0

Methods

put :: Fixed a -> Put Source #

get :: Get (Fixed a) Source #

putList :: [Fixed a] -> Put Source #

Binary a => Binary (Min a)

Since: 0.8.4.0

Methods

put :: Min a -> Put Source #

get :: Get (Min a) Source #

putList :: [Min a] -> Put Source #

Binary a => Binary (Max a)

Since: 0.8.4.0

Methods

put :: Max a -> Put Source #

get :: Get (Max a) Source #

putList :: [Max a] -> Put Source #

Binary a => Binary (First a)

Since: 0.8.4.0

Methods

put :: First a -> Put Source #

get :: Get (First a) Source #

putList :: [First a] -> Put Source #

Binary a => Binary (Last a)

Since: 0.8.4.0

Methods

put :: Last a -> Put Source #

get :: Get (Last a) Source #

putList :: [Last a] -> Put Source #

Binary m => Binary (WrappedMonoid m)

Since: 0.8.4.0

Binary a => Binary (Option a)

Since: 0.8.4.0

Methods

put :: Option a -> Put Source #

get :: Get (Option a) Source #

putList :: [Option a] -> Put Source #

Binary a => Binary (NonEmpty a)

Since: 0.8.4.0

Binary a => Binary (Dual a)

Since: 0.8.4.0

Methods

put :: Dual a -> Put Source #

get :: Get (Dual a) Source #

putList :: [Dual a] -> Put Source #

Binary a => Binary (Sum a)

Since: 0.8.4.0

Methods

put :: Sum a -> Put Source #

get :: Get (Sum a) Source #

putList :: [Sum a] -> Put Source #

Binary a => Binary (Product a)

Since: 0.8.4.0

Methods

put :: Product a -> Put Source #

get :: Get (Product a) Source #

putList :: [Product a] -> Put Source #

Binary a => Binary (First a)

Since: 0.8.4.0

Methods

put :: First a -> Put Source #

get :: Get (First a) Source #

putList :: [First a] -> Put Source #

Binary a => Binary (Last a)

Since: 0.8.4.0

Methods

put :: Last a -> Put Source #

get :: Get (Last a) Source #

putList :: [Last a] -> Put Source #

Binary e => Binary (IntMap e) 

Methods

put :: IntMap e -> Put Source #

get :: Get (IntMap e) Source #

putList :: [IntMap e] -> Put Source #

Binary e => Binary (Tree e) 

Methods

put :: Tree e -> Put Source #

get :: Get (Tree e) Source #

putList :: [Tree e] -> Put Source #

Binary e => Binary (Seq e) 

Methods

put :: Seq e -> Put Source #

get :: Get (Seq e) Source #

putList :: [Seq e] -> Put Source #

Binary a => Binary (Set a) 

Methods

put :: Set a -> Put Source #

get :: Get (Set a) Source #

putList :: [Set a] -> Put Source #

Binary a => Binary (Last' a) # 

Methods

put :: Last' a -> Put Source #

get :: Get (Last' a) Source #

putList :: [Last' a] -> Put Source #

(IsNode a, Binary a, Show (Key a)) => Binary (Graph a) # 

Methods

put :: Graph a -> Put Source #

get :: Get (Graph a) Source #

putList :: [Graph a] -> Put Source #

Binary c => Binary (Condition c) # 
Binary dir => Binary (InstallDirs dir) # 
(Ord a, Binary a) => Binary (NubList a) #

Binary instance for 'NubList a' is the same as for '[a]'. For put, we just pull off constructor and put the list. For get, we get the list and make a NubList out of it using toNubList.

Methods

put :: NubList a -> Put Source #

get :: Get (NubList a) Source #

putList :: [NubList a] -> Put Source #

Binary a => Binary (PackageIndex a) # 
Binary a => Binary (Flag a) # 

Methods

put :: Flag a -> Put Source #

get :: Get (Flag a) Source #

putList :: [Flag a] -> Put Source #

(Binary a, Binary b) => Binary (Either a b) 

Methods

put :: Either a b -> Put Source #

get :: Get (Either a b) Source #

putList :: [Either a b] -> Put Source #

Typeable k a => Binary (TypeRep k a) 

Methods

put :: TypeRep k a -> Put Source #

get :: Get (TypeRep k a) Source #

putList :: [TypeRep k a] -> Put Source #

(Binary a, Binary b) => Binary (a, b) 

Methods

put :: (a, b) -> Put Source #

get :: Get (a, b) Source #

putList :: [(a, b)] -> Put Source #

(Binary i, Ix i, Binary e, IArray UArray e) => Binary (UArray i e) 

Methods

put :: UArray i e -> Put Source #

get :: Get (UArray i e) Source #

putList :: [UArray i e] -> Put Source #

(Binary i, Ix i, Binary e) => Binary (Array i e) 

Methods

put :: Array i e -> Put Source #

get :: Get (Array i e) Source #

putList :: [Array i e] -> Put Source #

(Binary a, Binary b) => Binary (Arg a b)

Since: 0.8.4.0

Methods

put :: Arg a b -> Put Source #

get :: Get (Arg a b) Source #

putList :: [Arg a b] -> Put Source #

(Binary k, Binary e) => Binary (Map k e) 

Methods

put :: Map k e -> Put Source #

get :: Get (Map k e) Source #

putList :: [Map k e] -> Put Source #

(Binary a, Binary b, Binary c) => Binary (a, b, c) 

Methods

put :: (a, b, c) -> Put Source #

get :: Get (a, b, c) Source #

putList :: [(a, b, c)] -> Put Source #

Binary (f a) => Binary (Alt k f a)

Since: 0.8.4.0

Methods

put :: Alt k f a -> Put Source #

get :: Get (Alt k f a) Source #

putList :: [Alt k f a] -> Put Source #

(Binary v, Binary c, Binary a) => Binary (CondBranch v c a) # 

Methods

put :: CondBranch v c a -> Put Source #

get :: Get (CondBranch v c a) Source #

putList :: [CondBranch v c a] -> Put Source #

(Binary v, Binary c, Binary a) => Binary (CondTree v c a) # 

Methods

put :: CondTree v c a -> Put Source #

get :: Get (CondTree v c a) Source #

putList :: [CondTree v c a] -> Put Source #

(Binary a, Binary b, Binary c, Binary d) => Binary (a, b, c, d) 

Methods

put :: (a, b, c, d) -> Put Source #

get :: Get (a, b, c, d) Source #

putList :: [(a, b, c, d)] -> Put Source #

(Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a, b, c, d, e) 

Methods

put :: (a, b, c, d, e) -> Put Source #

get :: Get (a, b, c, d, e) Source #

putList :: [(a, b, c, d, e)] -> Put Source #

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a, b, c, d, e, f) 

Methods

put :: (a, b, c, d, e, f) -> Put Source #

get :: Get (a, b, c, d, e, f) Source #

putList :: [(a, b, c, d, e, f)] -> Put Source #

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g) => Binary (a, b, c, d, e, f, g) 

Methods

put :: (a, b, c, d, e, f, g) -> Put Source #

get :: Get (a, b, c, d, e, f, g) Source #

putList :: [(a, b, c, d, e, f, g)] -> Put Source #

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h) => Binary (a, b, c, d, e, f, g, h) 

Methods

put :: (a, b, c, d, e, f, g, h) -> Put Source #

get :: Get (a, b, c, d, e, f, g, h) Source #

putList :: [(a, b, c, d, e, f, g, h)] -> Put Source #

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h, Binary i) => Binary (a, b, c, d, e, f, g, h, i) 

Methods

put :: (a, b, c, d, e, f, g, h, i) -> Put Source #

get :: Get (a, b, c, d, e, f, g, h, i) Source #

putList :: [(a, b, c, d, e, f, g, h, i)] -> Put Source #

(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h, Binary i, Binary j) => Binary (a, b, c, d, e, f, g, h, i, j) 

Methods

put :: (a, b, c, d, e, f, g, h, i, j) -> Put Source #

get :: Get (a, b, c, d, e, f, g, h, i, j) Source #

putList :: [(a, b, c, d, e, f, g, h, i, j)] -> Put Source #

class Applicative f => Alternative (f :: * -> *) where Source #

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

  • some v = (:) <$> v <*> many v
  • many v = some v <|> pure []

Minimal complete definition

empty, (<|>)

Methods

empty :: f a Source #

The identity of <|>

(<|>) :: f a -> f a -> f a infixl 3 Source #

An associative binary operation

some :: f a -> f [a] Source #

One or more.

many :: f a -> f [a] Source #

Zero or more.

Instances

Alternative []

Since: 2.1

Methods

empty :: [a] Source #

(<|>) :: [a] -> [a] -> [a] Source #

some :: [a] -> [[a]] Source #

many :: [a] -> [[a]] Source #

Alternative Maybe

Since: 2.1

Methods

empty :: Maybe a Source #

(<|>) :: Maybe a -> Maybe a -> Maybe a Source #

some :: Maybe a -> Maybe [a] Source #

many :: Maybe a -> Maybe [a] Source #

Alternative IO

Since: 4.9.0.0

Methods

empty :: IO a Source #

(<|>) :: IO a -> IO a -> IO a Source #

some :: IO a -> IO [a] Source #

many :: IO a -> IO [a] Source #

Alternative P

Since: 4.5.0.0

Methods

empty :: P a Source #

(<|>) :: P a -> P a -> P a Source #

some :: P a -> P [a] Source #

many :: P a -> P [a] Source #

Alternative Option

Since: 4.9.0.0

Methods

empty :: Option a Source #

(<|>) :: Option a -> Option a -> Option a Source #

some :: Option a -> Option [a] Source #

many :: Option a -> Option [a] Source #

Alternative STM

Since: 4.8.0.0

Methods

empty :: STM a Source #

(<|>) :: STM a -> STM a -> STM a Source #

some :: STM a -> STM [a] Source #

many :: STM a -> STM [a] Source #

Alternative ReadPrec

Since: 4.6.0.0

Alternative ReadP

Since: 4.6.0.0

Methods

empty :: ReadP a Source #

(<|>) :: ReadP a -> ReadP a -> ReadP a Source #

some :: ReadP a -> ReadP [a] Source #

many :: ReadP a -> ReadP [a] Source #

Alternative Seq 

Methods

empty :: Seq a Source #

(<|>) :: Seq a -> Seq a -> Seq a Source #

some :: Seq a -> Seq [a] Source #

many :: Seq a -> Seq [a] Source #

Alternative Get

Since: 0.7.0.0

Methods

empty :: Get a Source #

(<|>) :: Get a -> Get a -> Get a Source #

some :: Get a -> Get [a] Source #

many :: Get a -> Get [a] Source #

Alternative Condition # 
Alternative (U1 *)

Since: 4.9.0.0

Methods

empty :: U1 * a Source #

(<|>) :: U1 * a -> U1 * a -> U1 * a Source #

some :: U1 * a -> U1 * [a] Source #

many :: U1 * a -> U1 * [a] Source #

MonadPlus m => Alternative (WrappedMonad m)

Since: 2.1

ArrowPlus a => Alternative (ArrowMonad a)

Since: 4.6.0.0

Alternative (Proxy *)

Since: 4.9.0.0

Methods

empty :: Proxy * a Source #

(<|>) :: Proxy * a -> Proxy * a -> Proxy * a Source #

some :: Proxy * a -> Proxy * [a] Source #

many :: Proxy * a -> Proxy * [a] Source #

Alternative f => Alternative (Rec1 * f)

Since: 4.9.0.0

Methods

empty :: Rec1 * f a Source #

(<|>) :: Rec1 * f a -> Rec1 * f a -> Rec1 * f a Source #

some :: Rec1 * f a -> Rec1 * f [a] Source #

many :: Rec1 * f a -> Rec1 * f [a] Source #

(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)

Since: 2.1

Methods

empty :: WrappedArrow a b a Source #

(<|>) :: WrappedArrow a b a -> WrappedArrow a b a -> WrappedArrow a b a Source #

some :: WrappedArrow a b a -> WrappedArrow a b [a] Source #

many :: WrappedArrow a b a -> WrappedArrow a b [a] Source #

Alternative f => Alternative (Alt * f) 

Methods

empty :: Alt * f a Source #

(<|>) :: Alt * f a -> Alt * f a -> Alt * f a Source #

some :: Alt * f a -> Alt * f [a] Source #

many :: Alt * f a -> Alt * f [a] Source #

Monoid fail => Alternative (Progress step fail) # 

Methods

empty :: Progress step fail a Source #

(<|>) :: Progress step fail a -> Progress step fail a -> Progress step fail a Source #

some :: Progress step fail a -> Progress step fail [a] Source #

many :: Progress step fail a -> Progress step fail [a] Source #

(Alternative f, Alternative g) => Alternative ((:*:) * f g)

Since: 4.9.0.0

Methods

empty :: (* :*: f) g a Source #

(<|>) :: (* :*: f) g a -> (* :*: f) g a -> (* :*: f) g a Source #

some :: (* :*: f) g a -> (* :*: f) g [a] Source #

many :: (* :*: f) g a -> (* :*: f) g [a] Source #

(Alternative f, Alternative g) => Alternative (Product * f g)

Since: 4.9.0.0

Methods

empty :: Product * f g a Source #

(<|>) :: Product * f g a -> Product * f g a -> Product * f g a Source #

some :: Product * f g a -> Product * f g [a] Source #

many :: Product * f g a -> Product * f g [a] Source #

Alternative f => Alternative (M1 * i c f)

Since: 4.9.0.0

Methods

empty :: M1 * i c f a Source #

(<|>) :: M1 * i c f a -> M1 * i c f a -> M1 * i c f a Source #

some :: M1 * i c f a -> M1 * i c f [a] Source #

many :: M1 * i c f a -> M1 * i c f [a] Source #

(Alternative f, Applicative g) => Alternative ((:.:) * * f g)

Since: 4.9.0.0

Methods

empty :: (* :.: *) f g a Source #

(<|>) :: (* :.: *) f g a -> (* :.: *) f g a -> (* :.: *) f g a Source #

some :: (* :.: *) f g a -> (* :.: *) f g [a] Source #

many :: (* :.: *) f g a -> (* :.: *) f g [a] Source #

(Alternative f, Applicative g) => Alternative (Compose * * f g)

Since: 4.9.0.0

Methods

empty :: Compose * * f g a Source #

(<|>) :: Compose * * f g a -> Compose * * f g a -> Compose * * f g a Source #

some :: Compose * * f g a -> Compose * * f g [a] Source #

many :: Compose * * f g a -> Compose * * f g [a] Source #

class (Alternative m, Monad m) => MonadPlus (m :: * -> *) where Source #

Monads that also support choice and failure.

Methods

mzero :: m a Source #

the identity of mplus. It should also satisfy the equations

mzero >>= f  =  mzero
v >> mzero   =  mzero

mplus :: m a -> m a -> m a Source #

an associative operation

Instances

MonadPlus []

Since: 2.1

Methods

mzero :: [a] Source #

mplus :: [a] -> [a] -> [a] Source #

MonadPlus Maybe

Since: 2.1

Methods

mzero :: Maybe a Source #

mplus :: Maybe a -> Maybe a -> Maybe a Source #

MonadPlus IO

Since: 4.9.0.0

Methods

mzero :: IO a Source #

mplus :: IO a -> IO a -> IO a Source #

MonadPlus P

Since: 2.1

Methods

mzero :: P a Source #

mplus :: P a -> P a -> P a Source #

MonadPlus Option

Since: 4.9.0.0

Methods

mzero :: Option a Source #

mplus :: Option a -> Option a -> Option a Source #

MonadPlus STM

Since: 4.3.0.0

Methods

mzero :: STM a Source #

mplus :: STM a -> STM a -> STM a Source #

MonadPlus ReadPrec

Since: 2.1

MonadPlus ReadP

Since: 2.1

Methods

mzero :: ReadP a Source #

mplus :: ReadP a -> ReadP a -> ReadP a Source #

MonadPlus Seq 

Methods

mzero :: Seq a Source #

mplus :: Seq a -> Seq a -> Seq a Source #

MonadPlus Get

Since: 0.7.1.0

Methods

mzero :: Get a Source #

mplus :: Get a -> Get a -> Get a Source #

MonadPlus Condition # 
MonadPlus (U1 *)

Since: 4.9.0.0

Methods

mzero :: U1 * a Source #

mplus :: U1 * a -> U1 * a -> U1 * a Source #

(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)

Since: 4.6.0.0

Methods

mzero :: ArrowMonad a a Source #

mplus :: ArrowMonad a a -> ArrowMonad a a -> ArrowMonad a a Source #

MonadPlus (Proxy *)

Since: 4.9.0.0

Methods

mzero :: Proxy * a Source #

mplus :: Proxy * a -> Proxy * a -> Proxy * a Source #

MonadPlus f => MonadPlus (Rec1 * f)

Since: 4.9.0.0

Methods

mzero :: Rec1 * f a Source #

mplus :: Rec1 * f a -> Rec1 * f a -> Rec1 * f a Source #

MonadPlus f => MonadPlus (Alt * f) 

Methods

mzero :: Alt * f a Source #

mplus :: Alt * f a -> Alt * f a -> Alt * f a Source #

(MonadPlus f, MonadPlus g) => MonadPlus ((:*:) * f g)

Since: 4.9.0.0

Methods

mzero :: (* :*: f) g a Source #

mplus :: (* :*: f) g a -> (* :*: f) g a -> (* :*: f) g a Source #

(MonadPlus f, MonadPlus g) => MonadPlus (Product * f g)

Since: 4.9.0.0

Methods

mzero :: Product * f g a Source #

mplus :: Product * f g a -> Product * f g a -> Product * f g a Source #

MonadPlus f => MonadPlus (M1 * i c f)

Since: 4.9.0.0

Methods

mzero :: M1 * i c f a Source #

mplus :: M1 * i c f a -> M1 * i c f a -> M1 * i c f a Source #

class IsString a where Source #

Class for string-like datastructures; used by the overloaded string extension (-XOverloadedStrings in GHC).

Minimal complete definition

fromString

Methods

fromString :: String -> a Source #

Instances

IsString ByteString 
IsString ShortByteString 
IsString ByteString 
IsString Doc 
IsString CmdSpec

construct a ShellCommand from a string literal

Since: 1.2.1.0

IsString ShortText # 
IsString PkgconfigName #

mkPkgconfigName

Since: 2.0.0.2

IsString ComponentId #

mkComponentId

Since: 2.0.0.2

IsString AbiHash #

mkAbiHash

Since: 2.0.0.2

IsString ModuleName #

Construct a ModuleName from a valid module name String.

This is just a convenience function intended for valid module strings. It is an error if it is used with a string that is not a valid module name. If you are parsing user input then use simpleParse instead.

IsString PackageName #

mkPackageName

Since: 2.0.0.2

IsString UnqualComponentName #

mkUnqualComponentName

Since: 2.0.0.2

IsString UnitId #

mkUnitId

Since: 2.0.0.2

IsString MungedPackageName #

mkMungedPackageName

Since: 2.0.0.2

IsString FlagName #

mkFlagName

Since: 2.0.0.2

(~) * a Char => IsString [a]

(a ~ Char) context was introduced in 4.9.0.0

Since: 2.1

Methods

fromString :: String -> [a] Source #

IsString a => IsString (Identity a) 
IsString (Seq Char) 
IsString (Doc a) 

Methods

fromString :: String -> Doc a Source #

IsString a => IsString (Const * a b)

Since: 4.9.0.0

Methods

fromString :: String -> Const * a b Source #

Some types

type IO a = WithCallStack (IO a) Source #

data Map k a :: * -> * -> * Source #

A Map from keys k to values a.

Instances

Eq2 Map 

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Map a c -> Map b d -> Bool Source #

Ord2 Map 

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Map a c -> Map b d -> Ordering Source #

Show2 Map 

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Map a b -> ShowS Source #

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Map a b] -> ShowS Source #

Functor (Map k) 

Methods

fmap :: (a -> b) -> Map k a -> Map k b Source #

(<$) :: a -> Map k b -> Map k a Source #

Foldable (Map k) 

Methods

fold :: Monoid m => Map k m -> m Source #

foldMap :: Monoid m => (a -> m) -> Map k a -> m Source #

foldr :: (a -> b -> b) -> b -> Map k a -> b Source #

foldr' :: (a -> b -> b) -> b -> Map k a -> b Source #

foldl :: (b -> a -> b) -> b -> Map k a -> b Source #

foldl' :: (b -> a -> b) -> b -> Map k a -> b Source #

foldr1 :: (a -> a -> a) -> Map k a -> a Source #

foldl1 :: (a -> a -> a) -> Map k a -> a Source #

toList :: Map k a -> [a] Source #

null :: Map k a -> Bool Source #

length :: Map k a -> Int Source #

elem :: Eq a => a -> Map k a -> Bool Source #

maximum :: Ord a => Map k a -> a Source #

minimum :: Ord a => Map k a -> a Source #

sum :: Num a => Map k a -> a Source #

product :: Num a => Map k a -> a Source #

Traversable (Map k) 

Methods

traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) Source #

sequenceA :: Applicative f => Map k (f a) -> f (Map k a) Source #

mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) Source #

sequence :: Monad m => Map k (m a) -> m (Map k a) Source #

Eq k => Eq1 (Map k) 

Methods

liftEq :: (a -> b -> Bool) -> Map k a -> Map k b -> Bool Source #

Ord k => Ord1 (Map k) 

Methods

liftCompare :: (a -> b -> Ordering) -> Map k a -> Map k b -> Ordering Source #

(Ord k, Read k) => Read1 (Map k) 

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Map k a) Source #

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Map k a] Source #

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Map k a) Source #

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Map k a] Source #

Show k => Show1 (Map k) 

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Map k a -> ShowS Source #

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Map k a] -> ShowS Source #

Ord k => IsList (Map k v) 

Associated Types

type Item (Map k v) :: * Source #

Methods

fromList :: [Item (Map k v)] -> Map k v Source #

fromListN :: Int -> [Item (Map k v)] -> Map k v Source #

toList :: Map k v -> [Item (Map k v)] Source #

(Eq k, Eq a) => Eq (Map k a) 

Methods

(==) :: Map k a -> Map k a -> Bool #

(/=) :: Map k a -> Map k a -> Bool #

(Data k, Data a, Ord k) => Data (Map k a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Map k a -> c (Map k a) Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Map k a) Source #

toConstr :: Map k a -> Constr Source #

dataTypeOf :: Map k a -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Map k a)) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Map k a)) Source #

gmapT :: (forall b. Data b => b -> b) -> Map k a -> Map k a Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Map k a -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Map k a -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) Source #

(Ord k, Ord v) => Ord (Map k v) 

Methods

compare :: Map k v -> Map k v -> Ordering #

(<) :: Map k v -> Map k v -> Bool #

(<=) :: Map k v -> Map k v -> Bool #

(>) :: Map k v -> Map k v -> Bool #

(>=) :: Map k v -> Map k v -> Bool #

max :: Map k v -> Map k v -> Map k v #

min :: Map k v -> Map k v -> Map k v #

(Ord k, Read k, Read e) => Read (Map k e) 
(Show k, Show a) => Show (Map k a) 

Methods

showsPrec :: Int -> Map k a -> ShowS Source #

show :: Map k a -> String Source #

showList :: [Map k a] -> ShowS Source #

Ord k => Semigroup (Map k v) 

Methods

(<>) :: Map k v -> Map k v -> Map k v Source #

sconcat :: NonEmpty (Map k v) -> Map k v Source #

stimes :: Integral b => b -> Map k v -> Map k v Source #

Ord k => Monoid (Map k v) 

Methods

mempty :: Map k v Source #

mappend :: Map k v -> Map k v -> Map k v Source #

mconcat :: [Map k v] -> Map k v Source #

(NFData k, NFData a) => NFData (Map k a) 

Methods

rnf :: Map k a -> () Source #

(Binary k, Binary e) => Binary (Map k e) 

Methods

put :: Map k e -> Put Source #

get :: Get (Map k e) Source #

putList :: [Map k e] -> Put Source #

ModSubst a => ModSubst (Map k a) # 

Methods

modSubst :: OpenModuleSubst -> Map k a -> Map k a Source #

type Item (Map k v) 
type Item (Map k v) = (k, v)

Data.Maybe

catMaybes :: [Maybe a] -> [a] Source #

The catMaybes function takes a list of Maybes and returns a list of all the Just values.

Examples

Basic usage:

>>> catMaybes [Just 1, Nothing, Just 3]
[1,3]

When constructing a list of Maybe values, catMaybes can be used to return all of the "success" results (if the list is the result of a map, then mapMaybe would be more appropriate):

>>> import Text.Read ( readMaybe )
>>> [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[Just 1,Nothing,Just 3]
>>> catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[1,3]

mapMaybe :: (a -> Maybe b) -> [a] -> [b] Source #

The mapMaybe function is a version of map which can throw out elements. In particular, the functional argument returns something of type Maybe b. If this is Nothing, no element is added on to the result list. If it is Just b, then b is included in the result list.

Examples

Using mapMaybe f x is a shortcut for catMaybes $ map f x in most cases:

>>> import Text.Read ( readMaybe )
>>> let readMaybeInt = readMaybe :: String -> Maybe Int
>>> mapMaybe readMaybeInt ["1", "Foo", "3"]
[1,3]
>>> catMaybes $ map readMaybeInt ["1", "Foo", "3"]
[1,3]

If we map the Just constructor, the entire list should be returned:

>>> mapMaybe Just [1,2,3]
[1,2,3]

fromMaybe :: a -> Maybe a -> a Source #

The fromMaybe function takes a default value and and Maybe value. If the Maybe is Nothing, it returns the default values; otherwise, it returns the value contained in the Maybe.

Examples

Basic usage:

>>> fromMaybe "" (Just "Hello, World!")
"Hello, World!"
>>> fromMaybe "" Nothing
""

Read an integer from a string using readMaybe. If we fail to parse an integer, we want to return 0 by default:

>>> import Text.Read ( readMaybe )
>>> fromMaybe 0 (readMaybe "5")
5
>>> fromMaybe 0 (readMaybe "")
0

maybeToList :: Maybe a -> [a] Source #

The maybeToList function returns an empty list when given Nothing or a singleton list when not given Nothing.

Examples

Basic usage:

>>> maybeToList (Just 7)
[7]
>>> maybeToList Nothing
[]

One can use maybeToList to avoid pattern matching when combined with a function that (safely) works on lists:

>>> import Text.Read ( readMaybe )
>>> sum $ maybeToList (readMaybe "3")
3
>>> sum $ maybeToList (readMaybe "")
0

listToMaybe :: [a] -> Maybe a Source #

The listToMaybe function returns Nothing on an empty list or Just a where a is the first element of the list.

Examples

Basic usage:

>>> listToMaybe []
Nothing
>>> listToMaybe [9]
Just 9
>>> listToMaybe [1,2,3]
Just 1

Composing maybeToList with listToMaybe should be the identity on singleton/empty lists:

>>> maybeToList $ listToMaybe [5]
[5]
>>> maybeToList $ listToMaybe []
[]

But not on lists with more than one element:

>>> maybeToList $ listToMaybe [1,2,3]
[1]

isNothing :: Maybe a -> Bool Source #

The isNothing function returns True iff its argument is Nothing.

Examples

Basic usage:

>>> isNothing (Just 3)
False
>>> isNothing (Just ())
False
>>> isNothing Nothing
True

Only the outer constructor is taken into consideration:

>>> isNothing (Just Nothing)
False

isJust :: Maybe a -> Bool Source #

The isJust function returns True iff its argument is of the form Just _.

Examples

Basic usage:

>>> isJust (Just 3)
True
>>> isJust (Just ())
True
>>> isJust Nothing
False

Only the outer constructor is taken into consideration:

>>> isJust (Just Nothing)
True

Data.List

unfoldr :: (b -> Maybe (a, b)) -> b -> [a] Source #

The unfoldr function is a `dual' to foldr: while foldr reduces a list to a summary value, unfoldr builds a list from a seed value. The function takes the element and returns Nothing if it is done producing the list or returns Just (a,b), in which case, a is a prepended to the list and b is used as the next element in a recursive call. For example,

iterate f == unfoldr (\x -> Just (x, f x))

In some cases, unfoldr can undo a foldr operation:

unfoldr f' (foldr f z xs) == xs

if the following holds:

f' (f x y) = Just (x,y)
f' z       = Nothing

A simple use of unfoldr:

unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10
 [10,9,8,7,6,5,4,3,2,1]

isPrefixOf :: Eq a => [a] -> [a] -> Bool Source #

The isPrefixOf function takes two lists and returns True iff the first list is a prefix of the second.

isSuffixOf :: Eq a => [a] -> [a] -> Bool Source #

The isSuffixOf function takes two lists and returns True iff the first list is a suffix of the second. The second list must be finite.

intercalate :: [a] -> [[a]] -> [a] Source #

intercalate xs xss is equivalent to (concat (intersperse xs xss)). It inserts the list xs in between the lists in xss and concatenates the result.

intersperse :: a -> [a] -> [a] Source #

The intersperse function takes an element and a list and `intersperses' that element between the elements of the list. For example,

intersperse ',' "abcde" == "a,b,c,d,e"

sort :: Ord a => [a] -> [a] Source #

The sort function implements a stable sorting algorithm. It is a special case of sortBy, which allows the programmer to supply their own comparison function.

Elements are arranged from from lowest to highest, keeping duplicates in the order they appeared in the input.

sortBy :: (a -> a -> Ordering) -> [a] -> [a] Source #

The sortBy function is the non-overloaded version of sort.

nub :: Eq a => [a] -> [a] Source #

O(n^2). The nub function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means `essence'.) It is a special case of nubBy, which allows the programmer to supply their own equality test.

nubBy :: (a -> a -> Bool) -> [a] -> [a] Source #

The nubBy function behaves just like nub, except it uses a user-supplied equality predicate instead of the overloaded == function.

Data.Foldable

class Foldable (t :: * -> *) where Source #

Data structures that can be folded.

For example, given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Foldable Tree where
   foldMap f Empty = mempty
   foldMap f (Leaf x) = f x
   foldMap f (Node l k r) = foldMap f l `mappend` f k `mappend` foldMap f r

This is suitable even for abstract types, as the monoid is assumed to satisfy the monoid laws. Alternatively, one could define foldr:

instance Foldable Tree where
   foldr f z Empty = z
   foldr f z (Leaf x) = f x z
   foldr f z (Node l k r) = foldr f (f k (foldr f z r)) l

Foldable instances are expected to satisfy the following laws:

foldr f z t = appEndo (foldMap (Endo . f) t ) z
foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z
fold = foldMap id

sum, product, maximum, and minimum should all be essentially equivalent to foldMap forms, such as

sum = getSum . foldMap Sum

but may be less defined.

If the type is also a Functor instance, it should satisfy

foldMap f = fold . fmap f

which implies that

foldMap f . fmap g = foldMap (f . g)

Minimal complete definition

foldMap | foldr

Methods

foldMap :: Monoid m => (a -> m) -> t a -> m Source #

Map each element of the structure to a monoid, and combine the results.

foldr :: (a -> b -> b) -> b -> t a -> b Source #

Right-associative fold of a structure.

In the case of lists, foldr, when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, foldr can produce a terminating expression from an infinite list.

For a general Foldable structure this should be semantically identical to,

foldr f z = foldr f z . toList

foldl :: (b -> a -> b) -> b -> t a -> b Source #

Left-associative fold of a structure.

In the case of lists, foldl, when applied to a binary operator, a starting value (typically the left-identity of the operator), and a list, reduces the list using the binary operator, from left to right:

foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn

Note that to produce the outermost application of the operator the entire input list must be traversed. This means that foldl' will diverge if given an infinite list.

Also note that if you want an efficient left-fold, you probably want to use foldl' instead of foldl. The reason for this is that latter does not force the "inner" results (e.g. z f x1 in the above example) before applying them to the operator (e.g. to (f x2)). This results in a thunk chain O(n) elements long, which then must be evaluated from the outside-in.

For a general Foldable structure this should be semantically identical to,

foldl f z = foldl f z . toList

foldl' :: (b -> a -> b) -> b -> t a -> b Source #

Left-associative fold of a structure but with strict application of the operator.

This ensures that each step of the fold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite list to a single, monolithic result (e.g. length).

For a general Foldable structure this should be semantically identical to,

foldl f z = foldl' f z . toList

foldr1 :: (a -> a -> a) -> t a -> a Source #

A variant of foldr that has no base case, and thus may only be applied to non-empty structures.

foldr1 f = foldr1 f . toList

foldl1 :: (a -> a -> a) -> t a -> a Source #

A variant of foldl that has no base case, and thus may only be applied to non-empty structures.

foldl1 f = foldl1 f . toList

null :: t a -> Bool Source #

Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

length :: t a -> Int Source #

Returns the size/length of a finite structure as an Int. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

elem :: Eq a => a -> t a -> Bool infix 4 Source #

Does the element occur in the structure?

maximum :: Ord a => t a -> a Source #

The largest element of a non-empty structure.

minimum :: Ord a => t a -> a Source #

The least element of a non-empty structure.

sum :: Num a => t a -> a Source #

The sum function computes the sum of the numbers of a structure.

product :: Num a => t a -> a Source #

The product function computes the product of the numbers of a structure.

Instances

Foldable []

Since: 2.1

Methods

fold :: Monoid m => [m] -> m Source #

foldMap :: Monoid m => (a -> m) -> [a] -> m Source #

foldr :: (a -> b -> b) -> b -> [a] -> b Source #

foldr' :: (a -> b -> b) -> b -> [a] -> b Source #

foldl :: (b -> a -> b) -> b -> [a] -> b Source #

foldl' :: (b -> a -> b) -> b -> [a] -> b Source #

foldr1 :: (a -> a -> a) -> [a] -> a Source #

foldl1 :: (a -> a -> a) -> [a] -> a Source #

toList :: [a] -> [a] Source #

null :: [a] -> Bool Source #

length :: [a] -> Int Source #

elem :: Eq a => a -> [a] -> Bool Source #

maximum :: Ord a => [a] -> a Source #

minimum :: Ord a => [a] -> a Source #

sum :: Num a => [a] -> a Source #

product :: Num a => [a] -> a Source #

Foldable Maybe

Since: 2.1

Methods

fold :: Monoid m => Maybe m -> m Source #

foldMap :: Monoid m => (a -> m) -> Maybe a -> m Source #

foldr :: (a -> b -> b) -> b -> Maybe a -> b Source #

foldr' :: (a -> b -> b) -> b -> Maybe a -> b Source #

foldl :: (b -> a -> b) -> b -> Maybe a -> b Source #

foldl' :: (b -> a -> b) -> b -> Maybe a -> b Source #

foldr1 :: (a -> a -> a) -> Maybe a -> a Source #

foldl1 :: (a -> a -> a) -> Maybe a -> a Source #

toList :: Maybe a -> [a] Source #

null :: Maybe a -> Bool Source #

length :: Maybe a -> Int Source #

elem :: Eq a => a -> Maybe a -> Bool Source #

maximum :: Ord a => Maybe a -> a Source #

minimum :: Ord a => Maybe a -> a Source #

sum :: Num a => Maybe a -> a Source #

product :: Num a => Maybe a -> a Source #

Foldable Par1 

Methods

fold :: Monoid m => Par1 m -> m Source #

foldMap :: Monoid m => (a -> m) -> Par1 a -> m Source #

foldr :: (a -> b -> b) -> b -> Par1 a -> b Source #

foldr' :: (a -> b -> b) -> b -> Par1 a -> b Source #

foldl :: (b -> a -> b) -> b -> Par1 a -> b Source #

foldl' :: (b -> a -> b) -> b -> Par1 a -> b Source #

foldr1 :: (a -> a -> a) -> Par1 a -> a Source #

foldl1 :: (a -> a -> a) -> Par1 a -> a Source #

toList :: Par1 a -> [a] Source #

null :: Par1 a -> Bool Source #

length :: Par1 a -> Int Source #

elem :: Eq a => a -> Par1 a -> Bool Source #

maximum :: Ord a => Par1 a -> a Source #

minimum :: Ord a => Par1 a -> a Source #

sum :: Num a => Par1 a -> a Source #

product :: Num a => Par1 a -> a Source #

Foldable Complex 

Methods

fold :: Monoid m => Complex m -> m Source #

foldMap :: Monoid m => (a -> m) -> Complex a -> m Source #

foldr :: (a -> b -> b) -> b -> Complex a -> b Source #

foldr' :: (a -> b -> b) -> b -> Complex a -> b Source #

foldl :: (b -> a -> b) -> b -> Complex a -> b Source #

foldl' :: (b -> a -> b) -> b -> Complex a -> b Source #

foldr1 :: (a -> a -> a) -> Complex a -> a Source #

foldl1 :: (a -> a -> a) -> Complex a -> a Source #

toList :: Complex a -> [a] Source #

null :: Complex a -> Bool Source #

length :: Complex a -> Int Source #

elem :: Eq a => a -> Complex a -> Bool Source #

maximum :: Ord a => Complex a -> a Source #

minimum :: Ord a => Complex a -> a Source #

sum :: Num a => Complex a -> a Source #

product :: Num a => Complex a -> a Source #

Foldable Min

Since: 4.9.0.0

Methods

fold :: Monoid m => Min m -> m Source #

foldMap :: Monoid m => (a -> m) -> Min a -> m Source #

foldr :: (a -> b -> b) -> b -> Min a -> b Source #

foldr' :: (a -> b -> b) -> b -> Min a -> b Source #

foldl :: (b -> a -> b) -> b -> Min a -> b Source #

foldl' :: (b -> a -> b) -> b -> Min a -> b Source #

foldr1 :: (a -> a -> a) -> Min a -> a Source #

foldl1 :: (a -> a -> a) -> Min a -> a Source #

toList :: Min a -> [a] Source #

null :: Min a -> Bool Source #

length :: Min a -> Int Source #

elem :: Eq a => a -> Min a -> Bool Source #

maximum :: Ord a => Min a -> a Source #

minimum :: Ord a => Min a -> a Source #

sum :: Num a => Min a -> a Source #

product :: Num a => Min a -> a Source #

Foldable Max

Since: 4.9.0.0

Methods

fold :: Monoid m => Max m -> m Source #

foldMap :: Monoid m => (a -> m) -> Max a -> m Source #

foldr :: (a -> b -> b) -> b -> Max a -> b Source #

foldr' :: (a -> b -> b) -> b -> Max a -> b Source #

foldl :: (b -> a -> b) -> b -> Max a -> b Source #

foldl' :: (b -> a -> b) -> b -> Max a -> b Source #

foldr1 :: (a -> a -> a) -> Max a -> a Source #

foldl1 :: (a -> a -> a) -> Max a -> a Source #

toList :: Max a -> [a] Source #

null :: Max a -> Bool Source #

length :: Max a -> Int Source #

elem :: Eq a => a -> Max a -> Bool Source #

maximum :: Ord a => Max a -> a Source #

minimum :: Ord a => Max a -> a Source #

sum :: Num a => Max a -> a Source #

product :: Num a => Max a -> a Source #

Foldable First

Since: 4.9.0.0

Methods

fold :: Monoid m => First m -> m Source #

foldMap :: Monoid m => (a -> m) -> First a -> m Source #

foldr :: (a -> b -> b) -> b -> First a -> b Source #

foldr' :: (a -> b -> b) -> b -> First a -> b Source #

foldl :: (b -> a -> b) -> b -> First a -> b Source #

foldl' :: (b -> a -> b) -> b -> First a -> b Source #

foldr1 :: (a -> a -> a) -> First a -> a Source #

foldl1 :: (a -> a -> a) -> First a -> a Source #

toList :: First a -> [a] Source #

null :: First a -> Bool Source #

length :: First a -> Int Source #

elem :: Eq a => a -> First a -> Bool Source #

maximum :: Ord a => First a -> a Source #

minimum :: Ord a => First a -> a Source #

sum :: Num a => First a -> a Source #

product :: Num a => First a -> a Source #

Foldable Last

Since: 4.9.0.0

Methods

fold :: Monoid m => Last m -> m Source #

foldMap :: Monoid m => (a -> m) -> Last a -> m Source #

foldr :: (a -> b -> b) -> b -> Last a -> b Source #

foldr' :: (a -> b -> b) -> b -> Last a -> b Source #

foldl :: (b -> a -> b) -> b -> Last a -> b Source #

foldl' :: (b -> a -> b) -> b -> Last a -> b Source #

foldr1 :: (a -> a -> a) -> Last a -> a Source #

foldl1 :: (a -> a -> a) -> Last a -> a Source #

toList :: Last a -> [a] Source #

null :: Last a -> Bool Source #

length :: Last a -> Int Source #

elem :: Eq a => a -> Last a -> Bool Source #

maximum :: Ord a => Last a -> a Source #

minimum :: Ord a => Last a -> a Source #

sum :: Num a => Last a -> a Source #

product :: Num a => Last a -> a Source #

Foldable Option

Since: 4.9.0.0

Methods

fold :: Monoid m => Option m -> m Source #

foldMap :: Monoid m => (a -> m) -> Option a -> m Source #

foldr :: (a -> b -> b) -> b -> Option a -> b Source #

foldr' :: (a -> b -> b) -> b -> Option a -> b Source #

foldl :: (b -> a -> b) -> b -> Option a -> b Source #

foldl' :: (b -> a -> b) -> b -> Option a -> b Source #

foldr1 :: (a -> a -> a) -> Option a -> a Source #

foldl1 :: (a -> a -> a) -> Option a -> a Source #

toList :: Option a -> [a] Source #

null :: Option a -> Bool Source #

length :: Option a -> Int Source #

elem :: Eq a => a -> Option a -> Bool Source #

maximum :: Ord a => Option a -> a Source #

minimum :: Ord a => Option a -> a Source #

sum :: Num a => Option a -> a Source #

product :: Num a => Option a -> a Source #

Foldable NonEmpty

Since: 4.9.0.0

Methods

fold :: Monoid m => NonEmpty m -> m Source #

foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m Source #

foldr :: (a -> b -> b) -> b -> NonEmpty a -> b Source #

foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b Source #

foldl :: (b -> a -> b) -> b -> NonEmpty a -> b Source #

foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b Source #

foldr1 :: (a -> a -> a) -> NonEmpty a -> a Source #

foldl1 :: (a -> a -> a) -> NonEmpty a -> a Source #

toList :: NonEmpty a -> [a] Source #

null :: NonEmpty a -> Bool Source #

length :: NonEmpty a -> Int Source #

elem :: Eq a => a -> NonEmpty a -> Bool Source #

maximum :: Ord a => NonEmpty a -> a Source #

minimum :: Ord a => NonEmpty a -> a Source #

sum :: Num a => NonEmpty a -> a Source #

product :: Num a => NonEmpty a -> a Source #

Foldable ZipList 

Methods

fold :: Monoid m => ZipList m -> m Source #

foldMap :: Monoid m => (a -> m) -> ZipList a -> m Source #

foldr :: (a -> b -> b) -> b -> ZipList a -> b Source #

foldr' :: (a -> b -> b) -> b -> ZipList a -> b Source #

foldl :: (b -> a -> b) -> b -> ZipList a -> b Source #

foldl' :: (b -> a -> b) -> b -> ZipList a -> b Source #

foldr1 :: (a -> a -> a) -> ZipList a -> a Source #

foldl1 :: (a -> a -> a) -> ZipList a -> a Source #

toList :: ZipList a -> [a] Source #

null :: ZipList a -> Bool Source #

length :: ZipList a -> Int Source #

elem :: Eq a => a -> ZipList a -> Bool Source #

maximum :: Ord a => ZipList a -> a Source #

minimum :: Ord a => ZipList a -> a Source #

sum :: Num a => ZipList a -> a Source #

product :: Num a => ZipList a -> a Source #

Foldable Identity

Since: 4.8.0.0

Methods

fold :: Monoid m => Identity m -> m Source #

foldMap :: Monoid m => (a -> m) -> Identity a -> m Source #

foldr :: (a -> b -> b) -> b -> Identity a -> b Source #

foldr' :: (a -> b -> b) -> b -> Identity a -> b Source #

foldl :: (b -> a -> b) -> b -> Identity a -> b Source #

foldl' :: (b -> a -> b) -> b -> Identity a -> b Source #

foldr1 :: (a -> a -> a) -> Identity a -> a Source #

foldl1 :: (a -> a -> a) -> Identity a -> a Source #

toList :: Identity a -> [a] Source #

null :: Identity a -> Bool Source #

length :: Identity a -> Int Source #

elem :: Eq a => a -> Identity a -> Bool Source #

maximum :: Ord a => Identity a -> a Source #

minimum :: Ord a => Identity a -> a Source #

sum :: Num a => Identity a -> a Source #

product :: Num a => Identity a -> a Source #

Foldable Dual

Since: 4.8.0.0

Methods

fold :: Monoid m => Dual m -> m Source #

foldMap :: Monoid m => (a -> m) -> Dual a -> m Source #

foldr :: (a -> b -> b) -> b -> Dual a -> b Source #

foldr' :: (a -> b -> b) -> b -> Dual a -> b Source #

foldl :: (b -> a -> b) -> b -> Dual a -> b Source #

foldl' :: (b -> a -> b) -> b -> Dual a -> b Source #

foldr1 :: (a -> a -> a) -> Dual a -> a Source #

foldl1 :: (a -> a -> a) -> Dual a -> a Source #

toList :: Dual a -> [a] Source #

null :: Dual a -> Bool Source #

length :: Dual a -> Int Source #

elem :: Eq a => a -> Dual a -> Bool Source #

maximum :: Ord a => Dual a -> a Source #

minimum :: Ord a => Dual a -> a Source #

sum :: Num a => Dual a -> a Source #

product :: Num a => Dual a -> a Source #

Foldable Sum

Since: 4.8.0.0

Methods

fold :: Monoid m => Sum m -> m Source #

foldMap :: Monoid m => (a -> m) -> Sum a -> m Source #

foldr :: (a -> b -> b) -> b -> Sum a -> b Source #

foldr' :: (a -> b -> b) -> b -> Sum a -> b Source #

foldl :: (b -> a -> b) -> b -> Sum a -> b Source #

foldl' :: (b -> a -> b) -> b -> Sum a -> b Source #

foldr1 :: (a -> a -> a) -> Sum a -> a Source #

foldl1 :: (a -> a -> a) -> Sum a -> a Source #

toList :: Sum a -> [a] Source #

null :: Sum a -> Bool Source #

length :: Sum a -> Int Source #

elem :: Eq a => a -> Sum a -> Bool Source #

maximum :: Ord a => Sum a -> a Source #

minimum :: Ord a => Sum a -> a Source #

sum :: Num a => Sum a -> a Source #

product :: Num a => Sum a -> a Source #

Foldable Product

Since: 4.8.0.0

Methods

fold :: Monoid m => Product m -> m Source #

foldMap :: Monoid m => (a -> m) -> Product a -> m Source #

foldr :: (a -> b -> b) -> b -> Product a -> b Source #

foldr' :: (a -> b -> b) -> b -> Product a -> b Source #

foldl :: (b -> a -> b) -> b -> Product a -> b Source #

foldl' :: (b -> a -> b) -> b -> Product a -> b Source #

foldr1 :: (a -> a -> a) -> Product a -> a Source #

foldl1 :: (a -> a -> a) -> Product a -> a Source #

toList :: Product a -> [a] Source #

null :: Product a -> Bool Source #

length :: Product a -> Int Source #

elem :: Eq a => a -> Product a -> Bool Source #

maximum :: Ord a => Product a -> a Source #

minimum :: Ord a => Product a -> a Source #

sum :: Num a => Product a -> a Source #

product :: Num a => Product a -> a Source #

Foldable First

Since: 4.8.0.0

Methods

fold :: Monoid m => First m -> m Source #

foldMap :: Monoid m => (a -> m) -> First a -> m Source #

foldr :: (a -> b -> b) -> b -> First a -> b Source #

foldr' :: (a -> b -> b) -> b -> First a -> b Source #

foldl :: (b -> a -> b) -> b -> First a -> b Source #

foldl' :: (b -> a -> b) -> b -> First a -> b Source #

foldr1 :: (a -> a -> a) -> First a -> a Source #

foldl1 :: (a -> a -> a) -> First a -> a Source #

toList :: First a -> [a] Source #

null :: First a -> Bool Source #

length :: First a -> Int Source #

elem :: Eq a => a -> First a -> Bool Source #

maximum :: Ord a => First a -> a Source #

minimum :: Ord a => First a -> a Source #

sum :: Num a => First a -> a Source #

product :: Num a => First a -> a Source #

Foldable Last

Since: 4.8.0.0

Methods

fold :: Monoid m => Last m -> m Source #

foldMap :: Monoid m => (a -> m) -> Last a -> m Source #

foldr :: (a -> b -> b) -> b -> Last a -> b Source #

foldr' :: (a -> b -> b) -> b -> Last a -> b Source #

foldl :: (b -> a -> b) -> b -> Last a -> b Source #

foldl' :: (b -> a -> b) -> b -> Last a -> b Source #

foldr1 :: (a -> a -> a) -> Last a -> a Source #

foldl1 :: (a -> a -> a) -> Last a -> a Source #

toList :: Last a -> [a] Source #

null :: Last a -> Bool Source #

length :: Last a -> Int Source #

elem :: Eq a => a -> Last a -> Bool Source #

maximum :: Ord a => Last a -> a Source #

minimum :: Ord a => Last a -> a Source #

sum :: Num a => Last a -> a Source #

product :: Num a => Last a -> a Source #

Foldable IntMap 

Methods

fold :: Monoid m => IntMap m -> m Source #

foldMap :: Monoid m => (a -> m) -> IntMap a -> m Source #

foldr :: (a -> b -> b) -> b -> IntMap a -> b Source #

foldr' :: (a -> b -> b) -> b -> IntMap a -> b Source #

foldl :: (b -> a -> b) -> b -> IntMap a -> b Source #

foldl' :: (b -> a -> b) -> b -> IntMap a -> b Source #

foldr1 :: (a -> a -> a) -> IntMap a -> a Source #

foldl1 :: (a -> a -> a) -> IntMap a -> a Source #

toList :: IntMap a -> [a] Source #

null :: IntMap a -> Bool Source #

length :: IntMap a -> Int Source #

elem :: Eq a => a -> IntMap a -> Bool Source #

maximum :: Ord a => IntMap a -> a Source #

minimum :: Ord a => IntMap a -> a Source #

sum :: Num a => IntMap a -> a Source #

product :: Num a => IntMap a -> a Source #

Foldable SCC 

Methods

fold :: Monoid m => SCC m -> m Source #

foldMap :: Monoid m => (a -> m) -> SCC a -> m Source #

foldr :: (a -> b -> b) -> b -> SCC a -> b Source #

foldr' :: (a -> b -> b) -> b -> SCC a -> b Source #

foldl :: (b -> a -> b) -> b -> SCC a -> b Source #

foldl' :: (b -> a -> b) -> b -> SCC a -> b Source #

foldr1 :: (a -> a -> a) -> SCC a -> a Source #

foldl1 :: (a -> a -> a) -> SCC a -> a Source #

toList :: SCC a -> [a] Source #

null :: SCC a -> Bool Source #

length :: SCC a -> Int Source #

elem :: Eq a => a -> SCC a -> Bool Source #

maximum :: Ord a => SCC a -> a Source #

minimum :: Ord a => SCC a -> a Source #

sum :: Num a => SCC a -> a Source #

product :: Num a => SCC a -> a Source #

Foldable Tree 

Methods

fold :: Monoid m => Tree m -> m Source #

foldMap :: Monoid m => (a -> m) -> Tree a -> m Source #

foldr :: (a -> b -> b) -> b -> Tree a -> b Source #

foldr' :: (a -> b -> b) -> b -> Tree a -> b Source #

foldl :: (b -> a -> b) -> b -> Tree a -> b Source #

foldl' :: (b -> a -> b) -> b -> Tree a -> b Source #

foldr1 :: (a -> a -> a) -> Tree a -> a Source #

foldl1 :: (a -> a -> a) -> Tree a -> a Source #

toList :: Tree a -> [a] Source #

null :: Tree a -> Bool Source #

length :: Tree a -> Int Source #

elem :: Eq a => a -> Tree a -> Bool Source #

maximum :: Ord a => Tree a -> a Source #

minimum :: Ord a => Tree a -> a Source #

sum :: Num a => Tree a -> a Source #

product :: Num a => Tree a -> a Source #

Foldable Seq 

Methods

fold :: Monoid m => Seq m -> m Source #

foldMap :: Monoid m => (a -> m) -> Seq a -> m Source #

foldr :: (a -> b -> b) -> b -> Seq a -> b Source #

foldr' :: (a -> b -> b) -> b -> Seq a -> b Source #

foldl :: (b -> a -> b) -> b -> Seq a -> b Source #

foldl' :: (b -> a -> b) -> b -> Seq a -> b Source #

foldr1 :: (a -> a -> a) -> Seq a -> a Source #

foldl1 :: (a -> a -> a) -> Seq a -> a Source #

toList :: Seq a -> [a] Source #

null :: Seq a -> Bool Source #

length :: Seq a -> Int Source #

elem :: Eq a => a -> Seq a -> Bool Source #

maximum :: Ord a => Seq a -> a Source #

minimum :: Ord a => Seq a -> a Source #

sum :: Num a => Seq a -> a Source #

product :: Num a => Seq a -> a Source #

Foldable FingerTree 

Methods

fold :: Monoid m => FingerTree m -> m Source #

foldMap :: Monoid m => (a -> m) -> FingerTree a -> m Source #

foldr :: (a -> b -> b) -> b -> FingerTree a -> b Source #

foldr' :: (a -> b -> b) -> b -> FingerTree a -> b Source #

foldl :: (b -> a -> b) -> b -> FingerTree a -> b Source #

foldl' :: (b -> a -> b) -> b -> FingerTree a -> b Source #

foldr1 :: (a -> a -> a) -> FingerTree a -> a Source #

foldl1 :: (a -> a -> a) -> FingerTree a -> a Source #

toList :: FingerTree a -> [a] Source #

null :: FingerTree a -> Bool Source #

length :: FingerTree a -> Int Source #

elem :: Eq a => a -> FingerTree a -> Bool Source #

maximum :: Ord a => FingerTree a -> a Source #

minimum :: Ord a => FingerTree a -> a Source #

sum :: Num a => FingerTree a -> a Source #

product :: Num a => FingerTree a -> a Source #

Foldable Digit 

Methods

fold :: Monoid m => Digit m -> m Source #

foldMap :: Monoid m => (a -> m) -> Digit a -> m Source #

foldr :: (a -> b -> b) -> b -> Digit a -> b Source #

foldr' :: (a -> b -> b) -> b -> Digit a -> b Source #

foldl :: (b -> a -> b) -> b -> Digit a -> b Source #

foldl' :: (b -> a -> b) -> b -> Digit a -> b Source #

foldr1 :: (a -> a -> a) -> Digit a -> a Source #

foldl1 :: (a -> a -> a) -> Digit a -> a Source #

toList :: Digit a -> [a] Source #

null :: Digit a -> Bool Source #

length :: Digit a -> Int Source #

elem :: Eq a => a -> Digit a -> Bool Source #

maximum :: Ord a => Digit a -> a Source #

minimum :: Ord a => Digit a -> a Source #

sum :: Num a => Digit a -> a Source #

product :: Num a => Digit a -> a Source #

Foldable Node 

Methods

fold :: Monoid m => Node m -> m Source #

foldMap :: Monoid m => (a -> m) -> Node a -> m Source #

foldr :: (a -> b -> b) -> b -> Node a -> b Source #

foldr' :: (a -> b -> b) -> b -> Node a -> b Source #

foldl :: (b -> a -> b) -> b -> Node a -> b Source #

foldl' :: (b -> a -> b) -> b -> Node a -> b Source #

foldr1 :: (a -> a -> a) -> Node a -> a Source #

foldl1 :: (a -> a -> a) -> Node a -> a Source #

toList :: Node a -> [a] Source #

null :: Node a -> Bool Source #

length :: Node a -> Int Source #

elem :: Eq a => a -> Node a -> Bool Source #

maximum :: Ord a => Node a -> a Source #

minimum :: Ord a => Node a -> a Source #

sum :: Num a => Node a -> a Source #

product :: Num a => Node a -> a Source #

Foldable Elem 

Methods

fold :: Monoid m => Elem m -> m Source #

foldMap :: Monoid m => (a -> m) -> Elem a -> m Source #

foldr :: (a -> b -> b) -> b -> Elem a -> b Source #

foldr' :: (a -> b -> b) -> b -> Elem a -> b Source #

foldl :: (b -> a -> b) -> b -> Elem a -> b Source #

foldl' :: (b -> a -> b) -> b -> Elem a -> b Source #

foldr1 :: (a -> a -> a) -> Elem a -> a Source #

foldl1 :: (a -> a -> a) -> Elem a -> a Source #

toList :: Elem a -> [a] Source #

null :: Elem a -> Bool Source #

length :: Elem a -> Int Source #

elem :: Eq a => a -> Elem a -> Bool Source #

maximum :: Ord a => Elem a -> a Source #

minimum :: Ord a => Elem a -> a Source #

sum :: Num a => Elem a -> a Source #

product :: Num a => Elem a -> a Source #

Foldable ViewL 

Methods

fold :: Monoid m => ViewL m -> m Source #

foldMap :: Monoid m => (a -> m) -> ViewL a -> m Source #

foldr :: (a -> b -> b) -> b -> ViewL a -> b Source #

foldr' :: (a -> b -> b) -> b -> ViewL a -> b Source #

foldl :: (b -> a -> b) -> b -> ViewL a -> b Source #

foldl' :: (b -> a -> b) -> b -> ViewL a -> b Source #

foldr1 :: (a -> a -> a) -> ViewL a -> a Source #

foldl1 :: (a -> a -> a) -> ViewL a -> a Source #

toList :: ViewL a -> [a] Source #

null :: ViewL a -> Bool Source #

length :: ViewL a -> Int Source #

elem :: Eq a => a -> ViewL a -> Bool Source #

maximum :: Ord a => ViewL a -> a Source #

minimum :: Ord a => ViewL a -> a Source #

sum :: Num a => ViewL a -> a Source #

product :: Num a => ViewL a -> a Source #

Foldable ViewR 

Methods

fold :: Monoid m => ViewR m -> m Source #

foldMap :: Monoid m => (a -> m) -> ViewR a -> m Source #

foldr :: (a -> b -> b) -> b -> ViewR a -> b Source #

foldr' :: (a -> b -> b) -> b -> ViewR a -> b Source #

foldl :: (b -> a -> b) -> b -> ViewR a -> b Source #

foldl' :: (b -> a -> b) -> b -> ViewR a -> b Source #

foldr1 :: (a -> a -> a) -> ViewR a -> a Source #

foldl1 :: (a -> a -> a) -> ViewR a -> a Source #

toList :: ViewR a -> [a] Source #

null :: ViewR a -> Bool Source #

length :: ViewR a -> Int Source #

elem :: Eq a => a -> ViewR a -> Bool Source #

maximum :: Ord a => ViewR a -> a Source #

minimum :: Ord a => ViewR a -> a Source #

sum :: Num a => ViewR a -> a Source #

product :: Num a => ViewR a -> a Source #

Foldable Set 

Methods

fold :: Monoid m => Set m -> m Source #

foldMap :: Monoid m => (a -> m) -> Set a -> m Source #

foldr :: (a -> b -> b) -> b -> Set a -> b Source #

foldr' :: (a -> b -> b) -> b -> Set a -> b Source #

foldl :: (b -> a -> b) -> b -> Set a -> b Source #

foldl' :: (b -> a -> b) -> b -> Set a -> b Source #

foldr1 :: (a -> a -> a) -> Set a -> a Source #

foldl1 :: (a -> a -> a) -> Set a -> a Source #

toList :: Set a -> [a] Source #

null :: Set a -> Bool Source #

length :: Set a -> Int Source #

elem :: Eq a => a -> Set a -> Bool Source #

maximum :: Ord a => Set a -> a Source #

minimum :: Ord a => Set a -> a Source #

sum :: Num a => Set a -> a Source #

product :: Num a => Set a -> a Source #

Foldable Graph # 

Methods

fold :: Monoid m => Graph m -> m Source #

foldMap :: Monoid m => (a -> m) -> Graph a -> m Source #

foldr :: (a -> b -> b) -> b -> Graph a -> b Source #

foldr' :: (a -> b -> b) -> b -> Graph a -> b Source #

foldl :: (b -> a -> b) -> b -> Graph a -> b Source #

foldl' :: (b -> a -> b) -> b -> Graph a -> b Source #

foldr1 :: (a -> a -> a) -> Graph a -> a Source #

foldl1 :: (a -> a -> a) -> Graph a -> a Source #

toList :: Graph a -> [a] Source #

null :: Graph a -> Bool Source #

length :: Graph a -> Int Source #

elem :: Eq a => a -> Graph a -> Bool Source #

maximum :: Ord a => Graph a -> a Source #

minimum :: Ord a => Graph a -> a Source #

sum :: Num a => Graph a -> a Source #

product :: Num a => Graph a -> a Source #

Foldable Condition # 

Methods

fold :: Monoid m => Condition m -> m Source #

foldMap :: Monoid m => (a -> m) -> Condition a -> m Source #

foldr :: (a -> b -> b) -> b -> Condition a -> b Source #

foldr' :: (a -> b -> b) -> b -> Condition a -> b Source #

foldl :: (b -> a -> b) -> b -> Condition a -> b Source #

foldl' :: (b -> a -> b) -> b -> Condition a -> b Source #

foldr1 :: (a -> a -> a) -> Condition a -> a Source #

foldl1 :: (a -> a -> a) -> Condition a -> a Source #

toList :: Condition a -> [a] Source #

null :: Condition a -> Bool Source #

length :: Condition a -> Int Source #

elem :: Eq a => a -> Condition a -> Bool Source #

maximum :: Ord a => Condition a -> a Source #

minimum :: Ord a => Condition a -> a Source #

sum :: Num a => Condition a -> a Source #

product :: Num a => Condition a -> a Source #

Foldable (Either a)

Since: 4.7.0.0

Methods

fold :: Monoid m => Either a m -> m Source #

foldMap :: Monoid m => (a -> m) -> Either a a -> m Source #

foldr :: (a -> b -> b) -> b -> Either a a -> b Source #

foldr' :: (a -> b -> b) -> b -> Either a a -> b Source #

foldl :: (b -> a -> b) -> b -> Either a a -> b Source #

foldl' :: (b -> a -> b) -> b -> Either a a -> b Source #

foldr1 :: (a -> a -> a) -> Either a a -> a Source #

foldl1 :: (a -> a -> a) -> Either a a -> a Source #

toList :: Either a a -> [a] Source #

null :: Either a a -> Bool Source #

length :: Either a a -> Int Source #

elem :: Eq a => a -> Either a a -> Bool Source #

maximum :: Ord a => Either a a -> a Source #

minimum :: Ord a => Either a a -> a Source #

sum :: Num a => Either a a -> a Source #

product :: Num a => Either a a -> a Source #

Foldable (V1 *) 

Methods

fold :: Monoid m => V1 * m -> m Source #

foldMap :: Monoid m => (a -> m) -> V1 * a -> m Source #

foldr :: (a -> b -> b) -> b -> V1 * a -> b Source #

foldr' :: (a -> b -> b) -> b -> V1 * a -> b Source #

foldl :: (b -> a -> b) -> b -> V1 * a -> b Source #

foldl' :: (b -> a -> b) -> b -> V1 * a -> b Source #

foldr1 :: (a -> a -> a) -> V1 * a -> a Source #

foldl1 :: (a -> a -> a) -> V1 * a -> a Source #

toList :: V1 * a -> [a] Source #

null :: V1 * a -> Bool Source #

length :: V1 * a -> Int Source #

elem :: Eq a => a -> V1 * a -> Bool Source #

maximum :: Ord a => V1 * a -> a Source #

minimum :: Ord a => V1 * a -> a Source #

sum :: Num a => V1 * a -> a Source #

product :: Num a => V1 * a -> a Source #

Foldable (U1 *)

Since: 4.9.0.0

Methods

fold :: Monoid m => U1 * m -> m Source #

foldMap :: Monoid m => (a -> m) -> U1 * a -> m Source #

foldr :: (a -> b -> b) -> b -> U1 * a -> b Source #

foldr' :: (a -> b -> b) -> b -> U1 * a -> b Source #

foldl :: (b -> a -> b) -> b -> U1 * a -> b Source #

foldl' :: (b -> a -> b) -> b -> U1 * a -> b Source #

foldr1 :: (a -> a -> a) -> U1 * a -> a Source #

foldl1 :: (a -> a -> a) -> U1 * a -> a Source #

toList :: U1 * a -> [a] Source #

null :: U1 * a -> Bool Source #

length :: U1 * a -> Int Source #

elem :: Eq a => a -> U1 * a -> Bool Source #

maximum :: Ord a => U1 * a -> a Source #

minimum :: Ord a => U1 * a -> a Source #

sum :: Num a => U1 * a -> a Source #

product :: Num a => U1 * a -> a Source #

Foldable ((,) a)

Since: 4.7.0.0

Methods

fold :: Monoid m => (a, m) -> m Source #

foldMap :: Monoid m => (a -> m) -> (a, a) -> m Source #

foldr :: (a -> b -> b) -> b -> (a, a) -> b Source #

foldr' :: (a -> b -> b) -> b -> (a, a) -> b Source #

foldl :: (b -> a -> b) -> b -> (a, a) -> b Source #

foldl' :: (b -> a -> b) -> b -> (a, a) -> b Source #

foldr1 :: (a -> a -> a) -> (a, a) -> a Source #

foldl1 :: (a -> a -> a) -> (a, a) -> a Source #

toList :: (a, a) -> [a] Source #

null :: (a, a) -> Bool Source #

length :: (a, a) -> Int Source #

elem :: Eq a => a -> (a, a) -> Bool Source #

maximum :: Ord a => (a, a) -> a Source #

minimum :: Ord a => (a, a) -> a Source #

sum :: Num a => (a, a) -> a Source #

product :: Num a => (a, a) -> a Source #

Foldable (Array i)

Since: 4.8.0.0

Methods

fold :: Monoid m => Array i m -> m Source #

foldMap :: Monoid m => (a -> m) -> Array i a -> m Source #

foldr :: (a -> b -> b) -> b -> Array i a -> b Source #

foldr' :: (a -> b -> b) -> b -> Array i a -> b Source #

foldl :: (b -> a -> b) -> b -> Array i a -> b Source #

foldl' :: (b -> a -> b) -> b -> Array i a -> b Source #

foldr1 :: (a -> a -> a) -> Array i a -> a Source #

foldl1 :: (a -> a -> a) -> Array i a -> a Source #

toList :: Array i a -> [a] Source #

null :: Array i a -> Bool Source #

length :: Array i a -> Int Source #

elem :: Eq a => a -> Array i a -> Bool Source #

maximum :: Ord a => Array i a -> a Source #

minimum :: Ord a => Array i a -> a Source #

sum :: Num a => Array i a -> a Source #

product :: Num a => Array i a -> a Source #

Foldable (Arg a)

Since: 4.9.0.0

Methods

fold :: Monoid m => Arg a m -> m Source #

foldMap :: Monoid m => (a -> m) -> Arg a a -> m Source #

foldr :: (a -> b -> b) -> b -> Arg a a -> b Source #

foldr' :: (a -> b -> b) -> b -> Arg a a -> b Source #

foldl :: (b -> a -> b) -> b -> Arg a a -> b Source #

foldl' :: (b -> a -> b) -> b -> Arg a a -> b Source #

foldr1 :: (a -> a -> a) -> Arg a a -> a Source #

foldl1 :: (a -> a -> a) -> Arg a a -> a Source #

toList :: Arg a a -> [a] Source #

null :: Arg a a -> Bool Source #

length :: Arg a a -> Int Source #

elem :: Eq a => a -> Arg a a -> Bool Source #

maximum :: Ord a => Arg a a -> a Source #

minimum :: Ord a => Arg a a -> a Source #

sum :: Num a => Arg a a -> a Source #

product :: Num a => Arg a a -> a Source #

Foldable (Proxy *)

Since: 4.7.0.0

Methods

fold :: Monoid m => Proxy * m -> m Source #

foldMap :: Monoid m => (a -> m) -> Proxy * a -> m Source #

foldr :: (a -> b -> b) -> b -> Proxy * a -> b Source #

foldr' :: (a -> b -> b) -> b -> Proxy * a -> b Source #

foldl :: (b -> a -> b) -> b -> Proxy * a -> b Source #

foldl' :: (b -> a -> b) -> b -> Proxy * a -> b Source #

foldr1 :: (a -> a -> a) -> Proxy * a -> a Source #

foldl1 :: (a -> a -> a) -> Proxy * a -> a Source #

toList :: Proxy * a -> [a] Source #

null :: Proxy * a -> Bool Source #

length :: Proxy * a -> Int Source #

elem :: Eq a => a -> Proxy * a -> Bool Source #

maximum :: Ord a => Proxy * a -> a Source #

minimum :: Ord a => Proxy * a -> a Source #

sum :: Num a => Proxy * a -> a Source #

product :: Num a => Proxy * a -> a Source #

Foldable (Map k) 

Methods

fold :: Monoid m => Map k m -> m Source #

foldMap :: Monoid m => (a -> m) -> Map k a -> m Source #

foldr :: (a -> b -> b) -> b -> Map k a -> b Source #

foldr' :: (a -> b -> b) -> b -> Map k a -> b Source #

foldl :: (b -> a -> b) -> b -> Map k a -> b Source #

foldl' :: (b -> a -> b) -> b -> Map k a -> b Source #

foldr1 :: (a -> a -> a) -> Map k a -> a Source #

foldl1 :: (a -> a -> a) -> Map k a -> a Source #

toList :: Map k a -> [a] Source #

null :: Map k a -> Bool Source #

length :: Map k a -> Int Source #

elem :: Eq a => a -> Map k a -> Bool Source #

maximum :: Ord a => Map k a -> a Source #

minimum :: Ord a => Map k a -> a Source #

sum :: Num a => Map k a -> a Source #

product :: Num a => Map k a -> a Source #

Foldable f => Foldable (Rec1 * f) 

Methods

fold :: Monoid m => Rec1 * f m -> m Source #

foldMap :: Monoid m => (a -> m) -> Rec1 * f a -> m Source #

foldr :: (a -> b -> b) -> b -> Rec1 * f a -> b Source #

foldr' :: (a -> b -> b) -> b -> Rec1 * f a -> b Source #

foldl :: (b -> a -> b) -> b -> Rec1 * f a -> b Source #

foldl' :: (b -> a -> b) -> b -> Rec1 * f a -> b Source #

foldr1 :: (a -> a -> a) -> Rec1 * f a -> a Source #

foldl1 :: (a -> a -> a) -> Rec1 * f a -> a Source #

toList :: Rec1 * f a -> [a] Source #

null :: Rec1 * f a -> Bool Source #

length :: Rec1 * f a -> Int Source #

elem :: Eq a => a -> Rec1 * f a -> Bool Source #

maximum :: Ord a => Rec1 * f a -> a Source #

minimum :: Ord a => Rec1 * f a -> a Source #

sum :: Num a => Rec1 * f a -> a Source #

product :: Num a => Rec1 * f a -> a Source #

Foldable (URec * Char) 

Methods

fold :: Monoid m => URec * Char m -> m Source #

foldMap :: Monoid m => (a -> m) -> URec * Char a -> m Source #

foldr :: (a -> b -> b) -> b -> URec * Char a -> b Source #

foldr' :: (a -> b -> b) -> b -> URec * Char a -> b Source #

foldl :: (b -> a -> b) -> b -> URec * Char a -> b Source #

foldl' :: (b -> a -> b) -> b -> URec * Char a -> b Source #

foldr1 :: (a -> a -> a) -> URec * Char a -> a Source #

foldl1 :: (a -> a -> a) -> URec * Char a -> a Source #

toList :: URec * Char a -> [a] Source #

null :: URec * Char a -> Bool Source #

length :: URec * Char a -> Int Source #

elem :: Eq a => a -> URec * Char a -> Bool Source #

maximum :: Ord a => URec * Char a -> a Source #

minimum :: Ord a => URec * Char a -> a Source #

sum :: Num a => URec * Char a -> a Source #

product :: Num a => URec * Char a -> a Source #

Foldable (URec * Double) 

Methods

fold :: Monoid m => URec * Double m -> m Source #

foldMap :: Monoid m => (a -> m) -> URec * Double a -> m Source #

foldr :: (a -> b -> b) -> b -> URec * Double a -> b Source #

foldr' :: (a -> b -> b) -> b -> URec * Double a -> b Source #

foldl :: (b -> a -> b) -> b -> URec * Double a -> b Source #

foldl' :: (b -> a -> b) -> b -> URec * Double a -> b Source #

foldr1 :: (a -> a -> a) -> URec * Double a -> a Source #

foldl1 :: (a -> a -> a) -> URec * Double a -> a Source #

toList :: URec * Double a -> [a] Source #

null :: URec * Double a -> Bool Source #

length :: URec * Double a -> Int Source #

elem :: Eq a => a -> URec * Double a -> Bool Source #

maximum :: Ord a => URec * Double a -> a Source #

minimum :: Ord a => URec * Double a -> a Source #

sum :: Num a => URec * Double a -> a Source #

product :: Num a => URec * Double a -> a Source #

Foldable (URec * Float) 

Methods

fold :: Monoid m => URec * Float m -> m Source #

foldMap :: Monoid m => (a -> m) -> URec * Float a -> m Source #

foldr :: (a -> b -> b) -> b -> URec * Float a -> b Source #

foldr' :: (a -> b -> b) -> b -> URec * Float a -> b Source #

foldl :: (b -> a -> b) -> b -> URec * Float a -> b Source #

foldl' :: (b -> a -> b) -> b -> URec * Float a -> b Source #

foldr1 :: (a -> a -> a) -> URec * Float a -> a Source #

foldl1 :: (a -> a -> a) -> URec * Float a -> a Source #

toList :: URec * Float a -> [a] Source #

null :: URec * Float a -> Bool Source #

length :: URec * Float a -> Int Source #

elem :: Eq a => a -> URec * Float a -> Bool Source #

maximum :: Ord a => URec * Float a -> a Source #

minimum :: Ord a => URec * Float a -> a Source #

sum :: Num a => URec * Float a -> a Source #

product :: Num a => URec * Float a -> a Source #

Foldable (URec * Int) 

Methods

fold :: Monoid m => URec * Int m -> m Source #

foldMap :: Monoid m => (a -> m) -> URec * Int a -> m Source #

foldr :: (a -> b -> b) -> b -> URec * Int a -> b Source #

foldr' :: (a -> b -> b) -> b -> URec * Int a -> b Source #

foldl :: (b -> a -> b) -> b -> URec * Int a -> b Source #

foldl' :: (b -> a -> b) -> b -> URec * Int a -> b Source #

foldr1 :: (a -> a -> a) -> URec * Int a -> a Source #

foldl1 :: (a -> a -> a) -> URec * Int a -> a Source #

toList :: URec * Int a -> [a] Source #

null :: URec * Int a -> Bool Source #

length :: URec * Int a -> Int Source #

elem :: Eq a => a -> URec * Int a -> Bool Source #

maximum :: Ord a => URec * Int a -> a Source #

minimum :: Ord a => URec * Int a -> a Source #

sum :: Num a => URec * Int a -> a Source #

product :: Num a => URec * Int a -> a Source #

Foldable (URec * Word) 

Methods

fold :: Monoid m => URec * Word m -> m Source #

foldMap :: Monoid m => (a -> m) -> URec * Word a -> m Source #

foldr :: (a -> b -> b) -> b -> URec * Word a -> b Source #

foldr' :: (a -> b -> b) -> b -> URec * Word a -> b Source #

foldl :: (b -> a -> b) -> b -> URec * Word a -> b Source #

foldl' :: (b -> a -> b) -> b -> URec * Word a -> b Source #

foldr1 :: (a -> a -> a) -> URec * Word a -> a Source #

foldl1 :: (a -> a -> a) -> URec * Word a -> a Source #

toList :: URec * Word a -> [a] Source #

null :: URec * Word a -> Bool Source #

length :: URec * Word a -> Int Source #

elem :: Eq a => a -> URec * Word a -> Bool Source #

maximum :: Ord a => URec * Word a -> a Source #

minimum :: Ord a => URec * Word a -> a Source #

sum :: Num a => URec * Word a -> a Source #

product :: Num a => URec * Word a -> a Source #

Foldable (URec * (Ptr ())) 

Methods

fold :: Monoid m => URec * (Ptr ()) m -> m Source #

foldMap :: Monoid m => (a -> m) -> URec * (Ptr ()) a -> m Source #

foldr :: (a -> b -> b) -> b -> URec * (Ptr ()) a -> b Source #

foldr' :: (a -> b -> b) -> b -> URec * (Ptr ()) a -> b Source #

foldl :: (b -> a -> b) -> b -> URec * (Ptr ()) a -> b Source #

foldl' :: (b -> a -> b) -> b -> URec * (Ptr ()) a -> b Source #

foldr1 :: (a -> a -> a) -> URec * (Ptr ()) a -> a Source #

foldl1 :: (a -> a -> a) -> URec * (Ptr ()) a -> a Source #

toList :: URec * (Ptr ()) a -> [a] Source #

null :: URec * (Ptr ()) a -> Bool Source #

length :: URec * (Ptr ()) a -> Int Source #

elem :: Eq a => a -> URec * (Ptr ()) a -> Bool Source #

maximum :: Ord a => URec * (Ptr ()) a -> a Source #

minimum :: Ord a => URec * (Ptr ()) a -> a Source #

sum :: Num a => URec * (Ptr ()) a -> a Source #

product :: Num a => URec * (Ptr ()) a -> a Source #

Foldable (Const * m)

Since: 4.7.0.0

Methods

fold :: Monoid m => Const * m m -> m Source #

foldMap :: Monoid m => (a -> m) -> Const * m a -> m Source #

foldr :: (a -> b -> b) -> b -> Const * m a -> b Source #

foldr' :: (a -> b -> b) -> b -> Const * m a -> b Source #

foldl :: (b -> a -> b) -> b -> Const * m a -> b Source #

foldl' :: (b -> a -> b) -> b -> Const * m a -> b Source #

foldr1 :: (a -> a -> a) -> Const * m a -> a Source #

foldl1 :: (a -> a -> a) -> Const * m a -> a Source #

toList :: Const * m a -> [a] Source #

null :: Const * m a -> Bool Source #

length :: Const * m a -> Int Source #

elem :: Eq a => a -> Const * m a -> Bool Source #

maximum :: Ord a => Const * m a -> a Source #

minimum :: Ord a => Const * m a -> a Source #

sum :: Num a => Const * m a -> a Source #

product :: Num a => Const * m a -> a Source #

Foldable (CondBranch v c) # 

Methods

fold :: Monoid m => CondBranch v c m -> m Source #

foldMap :: Monoid m => (a -> m) -> CondBranch v c a -> m Source #

foldr :: (a -> b -> b) -> b -> CondBranch v c a -> b Source #

foldr' :: (a -> b -> b) -> b -> CondBranch v c a -> b Source #

foldl :: (b -> a -> b) -> b -> CondBranch v c a -> b Source #

foldl' :: (b -> a -> b) -> b -> CondBranch v c a -> b Source #

foldr1 :: (a -> a -> a) -> CondBranch v c a -> a Source #

foldl1 :: (a -> a -> a) -> CondBranch v c a -> a Source #

toList :: CondBranch v c a -> [a] Source #

null :: CondBranch v c a -> Bool Source #

length :: CondBranch v c a -> Int Source #

elem :: Eq a => a -> CondBranch v c a -> Bool Source #

maximum :: Ord a => CondBranch v c a -> a Source #

minimum :: Ord a => CondBranch v c a -> a Source #

sum :: Num a => CondBranch v c a -> a Source #

product :: Num a => CondBranch v c a -> a Source #

Foldable (CondTree v c) # 

Methods

fold :: Monoid m => CondTree v c m -> m Source #

foldMap :: Monoid m => (a -> m) -> CondTree v c a -> m Source #

foldr :: (a -> b -> b) -> b -> CondTree v c a -> b Source #

foldr' :: (a -> b -> b) -> b -> CondTree v c a -> b Source #

foldl :: (b -> a -> b) -> b -> CondTree v c a -> b Source #

foldl' :: (b -> a -> b) -> b -> CondTree v c a -> b Source #

foldr1 :: (a -> a -> a) -> CondTree v c a -> a Source #

foldl1 :: (a -> a -> a) -> CondTree v c a -> a Source #

toList :: CondTree v c a -> [a] Source #

null :: CondTree v c a -> Bool Source #

length :: CondTree v c a -> Int Source #

elem :: Eq a => a -> CondTree v c a -> Bool Source #

maximum :: Ord a => CondTree v c a -> a Source #

minimum :: Ord a => CondTree v c a -> a Source #

sum :: Num a => CondTree v c a -> a Source #

product :: Num a => CondTree v c a -> a Source #

Foldable (K1 * i c) 

Methods

fold :: Monoid m => K1 * i c m -> m Source #

foldMap :: Monoid m => (a -> m) -> K1 * i c a -> m Source #

foldr :: (a -> b -> b) -> b -> K1 * i c a -> b Source #

foldr' :: (a -> b -> b) -> b -> K1 * i c a -> b Source #

foldl :: (b -> a -> b) -> b -> K1 * i c a -> b Source #

foldl' :: (b -> a -> b) -> b -> K1 * i c a -> b Source #

foldr1 :: (a -> a -> a) -> K1 * i c a -> a Source #

foldl1 :: (a -> a -> a) -> K1 * i c a -> a Source #

toList :: K1 * i c a -> [a] Source #

null :: K1 * i c a -> Bool Source #

length :: K1 * i c a -> Int Source #

elem :: Eq a => a -> K1 * i c a -> Bool Source #

maximum :: Ord a => K1 * i c a -> a Source #

minimum :: Ord a => K1 * i c a -> a Source #

sum :: Num a => K1 * i c a -> a Source #

product :: Num a => K1 * i c a -> a Source #

(Foldable f, Foldable g) => Foldable ((:+:) * f g) 

Methods

fold :: Monoid m => (* :+: f) g m -> m Source #

foldMap :: Monoid m => (a -> m) -> (* :+: f) g a -> m Source #

foldr :: (a -> b -> b) -> b -> (* :+: f) g a -> b Source #

foldr' :: (a -> b -> b) -> b -> (* :+: f) g a -> b Source #

foldl :: (b -> a -> b) -> b -> (* :+: f) g a -> b Source #

foldl' :: (b -> a -> b) -> b -> (* :+: f) g a -> b Source #

foldr1 :: (a -> a -> a) -> (* :+: f) g a -> a Source #

foldl1 :: (a -> a -> a) -> (* :+: f) g a -> a Source #

toList :: (* :+: f) g a -> [a] Source #

null :: (* :+: f) g a -> Bool Source #

length :: (* :+: f) g a -> Int Source #

elem :: Eq a => a -> (* :+: f) g a -> Bool Source #

maximum :: Ord a => (* :+: f) g a -> a Source #

minimum :: Ord a => (* :+: f) g a -> a Source #

sum :: Num a => (* :+: f) g a -> a Source #

product :: Num a => (* :+: f) g a -> a Source #

(Foldable f, Foldable g) => Foldable ((:*:) * f g) 

Methods

fold :: Monoid m => (* :*: f) g m -> m Source #

foldMap :: Monoid m => (a -> m) -> (* :*: f) g a -> m Source #

foldr :: (a -> b -> b) -> b -> (* :*: f) g a -> b Source #

foldr' :: (a -> b -> b) -> b -> (* :*: f) g a -> b Source #

foldl :: (b -> a -> b) -> b -> (* :*: f) g a -> b Source #

foldl' :: (b -> a -> b) -> b -> (* :*: f) g a -> b Source #

foldr1 :: (a -> a -> a) -> (* :*: f) g a -> a Source #

foldl1 :: (a -> a -> a) -> (* :*: f) g a -> a Source #

toList :: (* :*: f) g a -> [a] Source #

null :: (* :*: f) g a -> Bool Source #

length :: (* :*: f) g a -> Int Source #

elem :: Eq a => a -> (* :*: f) g a -> Bool Source #

maximum :: Ord a => (* :*: f) g a -> a Source #

minimum :: Ord a => (* :*: f) g a -> a Source #

sum :: Num a => (* :*: f) g a -> a Source #

product :: Num a => (* :*: f) g a -> a Source #

(Foldable f, Foldable g) => Foldable (Product * f g)

Since: 4.9.0.0

Methods

fold :: Monoid m => Product * f g m -> m Source #

foldMap :: Monoid m => (a -> m) -> Product * f g a -> m Source #

foldr :: (a -> b -> b) -> b -> Product * f g a -> b Source #

foldr' :: (a -> b -> b) -> b -> Product * f g a -> b Source #

foldl :: (b -> a -> b) -> b -> Product * f g a -> b Source #

foldl' :: (b -> a -> b) -> b -> Product * f g a -> b Source #

foldr1 :: (a -> a -> a) -> Product * f g a -> a Source #

foldl1 :: (a -> a -> a) -> Product * f g a -> a Source #

toList :: Product * f g a -> [a] Source #

null :: Product * f g a -> Bool Source #

length :: Product * f g a -> Int Source #

elem :: Eq a => a -> Product * f g a -> Bool Source #

maximum :: Ord a => Product * f g a -> a Source #

minimum :: Ord a => Product * f g a -> a Source #

sum :: Num a => Product * f g a -> a Source #

product :: Num a => Product * f g a -> a Source #

(Foldable f, Foldable g) => Foldable (Sum * f g)

Since: 4.9.0.0

Methods

fold :: Monoid m => Sum * f g m -> m Source #

foldMap :: Monoid m => (a -> m) -> Sum * f g a -> m Source #

foldr :: (a -> b -> b) -> b -> Sum * f g a -> b Source #

foldr' :: (a -> b -> b) -> b -> Sum * f g a -> b Source #

foldl :: (b -> a -> b) -> b -> Sum * f g a -> b Source #

foldl' :: (b -> a -> b) -> b -> Sum * f g a -> b Source #

foldr1 :: (a -> a -> a) -> Sum * f g a -> a Source #

foldl1 :: (a -> a -> a) -> Sum * f g a -> a Source #

toList :: Sum * f g a -> [a] Source #

null :: Sum * f g a -> Bool Source #

length :: Sum * f g a -> Int Source #

elem :: Eq a => a -> Sum * f g a -> Bool Source #

maximum :: Ord a => Sum * f g a -> a Source #

minimum :: Ord a => Sum * f g a -> a Source #

sum :: Num a => Sum * f g a -> a Source #

product :: Num a => Sum * f g a -> a Source #

Foldable f => Foldable (M1 * i c f) 

Methods

fold :: Monoid m => M1 * i c f m -> m Source #

foldMap :: Monoid m => (a -> m) -> M1 * i c f a -> m Source #

foldr :: (a -> b -> b) -> b -> M1 * i c f a -> b Source #

foldr' :: (a -> b -> b) -> b -> M1 * i c f a -> b Source #

foldl :: (b -> a -> b) -> b -> M1 * i c f a -> b Source #

foldl' :: (b -> a -> b) -> b -> M1 * i c f a -> b Source #

foldr1 :: (a -> a -> a) -> M1 * i c f a -> a Source #

foldl1 :: (a -> a -> a) -> M1 * i c f a -> a Source #

toList :: M1 * i c f a -> [a] Source #

null :: M1 * i c f a -> Bool Source #

length :: M1 * i c f a -> Int Source #

elem :: Eq a => a -> M1 * i c f a -> Bool Source #

maximum :: Ord a => M1 * i c f a -> a Source #

minimum :: Ord a => M1 * i c f a -> a Source #

sum :: Num a => M1 * i c f a -> a Source #

product :: Num a => M1 * i c f a -> a Source #

(Foldable f, Foldable g) => Foldable ((:.:) * * f g) 

Methods

fold :: Monoid m => (* :.: *) f g m -> m Source #

foldMap :: Monoid m => (a -> m) -> (* :.: *) f g a -> m Source #

foldr :: (a -> b -> b) -> b -> (* :.: *) f g a -> b Source #

foldr' :: (a -> b -> b) -> b -> (* :.: *) f g a -> b Source #

foldl :: (b -> a -> b) -> b -> (* :.: *) f g a -> b Source #

foldl' :: (b -> a -> b) -> b -> (* :.: *) f g a -> b Source #

foldr1 :: (a -> a -> a) -> (* :.: *) f g a -> a Source #

foldl1 :: (a -> a -> a) -> (* :.: *) f g a -> a Source #

toList :: (* :.: *) f g a -> [a] Source #

null :: (* :.: *) f g a -> Bool Source #

length :: (* :.: *) f g a -> Int Source #

elem :: Eq a => a -> (* :.: *) f g a -> Bool Source #

maximum :: Ord a => (* :.: *) f g a -> a Source #

minimum :: Ord a => (* :.: *) f g a -> a Source #

sum :: Num a => (* :.: *) f g a -> a Source #

product :: Num a => (* :.: *) f g a -> a Source #

(Foldable f, Foldable g) => Foldable (Compose * * f g)

Since: 4.9.0.0

Methods

fold :: Monoid m => Compose * * f g m -> m Source #

foldMap :: Monoid m => (a -> m) -> Compose * * f g a -> m Source #

foldr :: (a -> b -> b) -> b -> Compose * * f g a -> b Source #

foldr' :: (a -> b -> b) -> b -> Compose * * f g a -> b Source #

foldl :: (b -> a -> b) -> b -> Compose * * f g a -> b Source #

foldl' :: (b -> a -> b) -> b -> Compose * * f g a -> b Source #

foldr1 :: (a -> a -> a) -> Compose * * f g a -> a Source #

foldl1 :: (a -> a -> a) -> Compose * * f g a -> a Source #

toList :: Compose * * f g a -> [a] Source #

null :: Compose * * f g a -> Bool Source #

length :: Compose * * f g a -> Int Source #

elem :: Eq a => a -> Compose * * f g a -> Bool Source #

maximum :: Ord a => Compose * * f g a -> a Source #

minimum :: Ord a => Compose * * f g a -> a Source #

sum :: Num a => Compose * * f g a -> a Source #

product :: Num a => Compose * * f g a -> a Source #

foldMap :: Foldable t => forall m a. Monoid m => (a -> m) -> t a -> m Source #

Map each element of the structure to a monoid, and combine the results.

foldr :: Foldable t => forall a b. (a -> b -> b) -> b -> t a -> b Source #

Right-associative fold of a structure.

In the case of lists, foldr, when applied to a binary operator, a starting value (typically the right-identity of the operator), and a list, reduces the list using the binary operator, from right to left:

foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)

Note that, since the head of the resulting expression is produced by an application of the operator to the first element of the list, foldr can produce a terminating expression from an infinite list.

For a general Foldable structure this should be semantically identical to,

foldr f z = foldr f z . toList

null :: Foldable t => forall a. t a -> Bool Source #

Test whether the structure is empty. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

length :: Foldable t => forall a. t a -> Int Source #

Returns the size/length of a finite structure as an Int. The default implementation is optimized for structures that are similar to cons-lists, because there is no general way to do better.

find :: Foldable t => (a -> Bool) -> t a -> Maybe a Source #

The find function takes a predicate and a structure and returns the leftmost element of the structure matching the predicate, or Nothing if there is no such element.

foldl' :: Foldable t => forall b a. (b -> a -> b) -> b -> t a -> b Source #

Left-associative fold of a structure but with strict application of the operator.

This ensures that each step of the fold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite list to a single, monolithic result (e.g. length).

For a general Foldable structure this should be semantically identical to,

foldl f z = foldl' f z . toList

traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f () Source #

Map each element of a structure to an action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see traverse.

for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f () Source #

for_ is traverse_ with its arguments flipped. For a version that doesn't ignore the results see for.

>>> for_ [1..4] print
1
2
3
4

Data.Traversable

class (Functor t, Foldable t) => Traversable (t :: * -> *) where Source #

Functors representing data structures that can be traversed from left to right.

A definition of traverse must satisfy the following laws:

naturality
t . traverse f = traverse (t . f) for every applicative transformation t
identity
traverse Identity = Identity
composition
traverse (Compose . fmap g . f) = Compose . fmap (traverse g) . traverse f

A definition of sequenceA must satisfy the following laws:

naturality
t . sequenceA = sequenceA . fmap t for every applicative transformation t
identity
sequenceA . fmap Identity = Identity
composition
sequenceA . fmap Compose = Compose . fmap sequenceA . sequenceA

where an applicative transformation is a function

t :: (Applicative f, Applicative g) => f a -> g a

preserving the Applicative operations, i.e.

and the identity functor Identity and composition of functors Compose are defined as

  newtype Identity a = Identity a

  instance Functor Identity where
    fmap f (Identity x) = Identity (f x)

  instance Applicative Identity where
    pure x = Identity x
    Identity f <*> Identity x = Identity (f x)

  newtype Compose f g a = Compose (f (g a))

  instance (Functor f, Functor g) => Functor (Compose f g) where
    fmap f (Compose x) = Compose (fmap (fmap f) x)

  instance (Applicative f, Applicative g) => Applicative (Compose f g) where
    pure x = Compose (pure (pure x))
    Compose f <*> Compose x = Compose ((<*>) <$> f <*> x)

(The naturality law is implied by parametricity.)

Instances are similar to Functor, e.g. given a data type

data Tree a = Empty | Leaf a | Node (Tree a) a (Tree a)

a suitable instance would be

instance Traversable Tree where
   traverse f Empty = pure Empty
   traverse f (Leaf x) = Leaf <$> f x
   traverse f (Node l k r) = Node <$> traverse f l <*> f k <*> traverse f r

This is suitable even for abstract types, as the laws for <*> imply a form of associativity.

The superclass instances should satisfy the following:

Minimal complete definition

traverse | sequenceA

Methods

traverse :: Applicative f => (a -> f b) -> t a -> f (t b) Source #

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

sequenceA :: Applicative f => t (f a) -> f (t a) Source #

Evaluate each action in the structure from left to right, and and collect the results. For a version that ignores the results see sequenceA_.

Instances

Traversable []

Since: 2.1

Methods

traverse :: Applicative f => (a -> f b) -> [a] -> f [b] Source #

sequenceA :: Applicative f => [f a] -> f [a] Source #

mapM :: Monad m => (a -> m b) -> [a] -> m [b] Source #

sequence :: Monad m => [m a] -> m [a] Source #

Traversable Maybe

Since: 2.1

Methods

traverse :: Applicative f => (a -> f b) -> Maybe a -> f (Maybe b) Source #

sequenceA :: Applicative f => Maybe (f a) -> f (Maybe a) Source #

mapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) Source #

sequence :: Monad m => Maybe (m a) -> m (Maybe a) Source #

Traversable Par1 

Methods

traverse :: Applicative f => (a -> f b) -> Par1 a -> f (Par1 b) Source #

sequenceA :: Applicative f => Par1 (f a) -> f (Par1 a) Source #

mapM :: Monad m => (a -> m b) -> Par1 a -> m (Par1 b) Source #

sequence :: Monad m => Par1 (m a) -> m (Par1 a) Source #

Traversable Complex 

Methods

traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b) Source #

sequenceA :: Applicative f => Complex (f a) -> f (Complex a) Source #

mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b) Source #

sequence :: Monad m => Complex (m a) -> m (Complex a) Source #

Traversable Min

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Min a -> f (Min b) Source #

sequenceA :: Applicative f => Min (f a) -> f (Min a) Source #

mapM :: Monad m => (a -> m b) -> Min a -> m (Min b) Source #

sequence :: Monad m => Min (m a) -> m (Min a) Source #

Traversable Max

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Max a -> f (Max b) Source #

sequenceA :: Applicative f => Max (f a) -> f (Max a) Source #

mapM :: Monad m => (a -> m b) -> Max a -> m (Max b) Source #

sequence :: Monad m => Max (m a) -> m (Max a) Source #

Traversable First

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> First a -> f (First b) Source #

sequenceA :: Applicative f => First (f a) -> f (First a) Source #

mapM :: Monad m => (a -> m b) -> First a -> m (First b) Source #

sequence :: Monad m => First (m a) -> m (First a) Source #

Traversable Last

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) Source #

sequenceA :: Applicative f => Last (f a) -> f (Last a) Source #

mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) Source #

sequence :: Monad m => Last (m a) -> m (Last a) Source #

Traversable Option

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Option a -> f (Option b) Source #

sequenceA :: Applicative f => Option (f a) -> f (Option a) Source #

mapM :: Monad m => (a -> m b) -> Option a -> m (Option b) Source #

sequence :: Monad m => Option (m a) -> m (Option a) Source #

Traversable NonEmpty

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) Source #

sequenceA :: Applicative f => NonEmpty (f a) -> f (NonEmpty a) Source #

mapM :: Monad m => (a -> m b) -> NonEmpty a -> m (NonEmpty b) Source #

sequence :: Monad m => NonEmpty (m a) -> m (NonEmpty a) Source #

Traversable ZipList

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) Source #

sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) Source #

mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) Source #

sequence :: Monad m => ZipList (m a) -> m (ZipList a) Source #

Traversable Identity 

Methods

traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b) Source #

sequenceA :: Applicative f => Identity (f a) -> f (Identity a) Source #

mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b) Source #

sequence :: Monad m => Identity (m a) -> m (Identity a) Source #

Traversable Dual

Since: 4.8.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Dual a -> f (Dual b) Source #

sequenceA :: Applicative f => Dual (f a) -> f (Dual a) Source #

mapM :: Monad m => (a -> m b) -> Dual a -> m (Dual b) Source #

sequence :: Monad m => Dual (m a) -> m (Dual a) Source #

Traversable Sum

Since: 4.8.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Sum a -> f (Sum b) Source #

sequenceA :: Applicative f => Sum (f a) -> f (Sum a) Source #

mapM :: Monad m => (a -> m b) -> Sum a -> m (Sum b) Source #

sequence :: Monad m => Sum (m a) -> m (Sum a) Source #

Traversable Product

Since: 4.8.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Product a -> f (Product b) Source #

sequenceA :: Applicative f => Product (f a) -> f (Product a) Source #

mapM :: Monad m => (a -> m b) -> Product a -> m (Product b) Source #

sequence :: Monad m => Product (m a) -> m (Product a) Source #

Traversable First

Since: 4.8.0.0

Methods

traverse :: Applicative f => (a -> f b) -> First a -> f (First b) Source #

sequenceA :: Applicative f => First (f a) -> f (First a) Source #

mapM :: Monad m => (a -> m b) -> First a -> m (First b) Source #

sequence :: Monad m => First (m a) -> m (First a) Source #

Traversable Last

Since: 4.8.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Last a -> f (Last b) Source #

sequenceA :: Applicative f => Last (f a) -> f (Last a) Source #

mapM :: Monad m => (a -> m b) -> Last a -> m (Last b) Source #

sequence :: Monad m => Last (m a) -> m (Last a) Source #

Traversable IntMap 

Methods

traverse :: Applicative f => (a -> f b) -> IntMap a -> f (IntMap b) Source #

sequenceA :: Applicative f => IntMap (f a) -> f (IntMap a) Source #

mapM :: Monad m => (a -> m b) -> IntMap a -> m (IntMap b) Source #

sequence :: Monad m => IntMap (m a) -> m (IntMap a) Source #

Traversable SCC 

Methods

traverse :: Applicative f => (a -> f b) -> SCC a -> f (SCC b) Source #

sequenceA :: Applicative f => SCC (f a) -> f (SCC a) Source #

mapM :: Monad m => (a -> m b) -> SCC a -> m (SCC b) Source #

sequence :: Monad m => SCC (m a) -> m (SCC a) Source #

Traversable Tree 

Methods

traverse :: Applicative f => (a -> f b) -> Tree a -> f (Tree b) Source #

sequenceA :: Applicative f => Tree (f a) -> f (Tree a) Source #

mapM :: Monad m => (a -> m b) -> Tree a -> m (Tree b) Source #

sequence :: Monad m => Tree (m a) -> m (Tree a) Source #

Traversable Seq 

Methods

traverse :: Applicative f => (a -> f b) -> Seq a -> f (Seq b) Source #

sequenceA :: Applicative f => Seq (f a) -> f (Seq a) Source #

mapM :: Monad m => (a -> m b) -> Seq a -> m (Seq b) Source #

sequence :: Monad m => Seq (m a) -> m (Seq a) Source #

Traversable FingerTree 

Methods

traverse :: Applicative f => (a -> f b) -> FingerTree a -> f (FingerTree b) Source #

sequenceA :: Applicative f => FingerTree (f a) -> f (FingerTree a) Source #

mapM :: Monad m => (a -> m b) -> FingerTree a -> m (FingerTree b) Source #

sequence :: Monad m => FingerTree (m a) -> m (FingerTree a) Source #

Traversable Digit 

Methods

traverse :: Applicative f => (a -> f b) -> Digit a -> f (Digit b) Source #

sequenceA :: Applicative f => Digit (f a) -> f (Digit a) Source #

mapM :: Monad m => (a -> m b) -> Digit a -> m (Digit b) Source #

sequence :: Monad m => Digit (m a) -> m (Digit a) Source #

Traversable Node 

Methods

traverse :: Applicative f => (a -> f b) -> Node a -> f (Node b) Source #

sequenceA :: Applicative f => Node (f a) -> f (Node a) Source #

mapM :: Monad m => (a -> m b) -> Node a -> m (Node b) Source #

sequence :: Monad m => Node (m a) -> m (Node a) Source #

Traversable Elem 

Methods

traverse :: Applicative f => (a -> f b) -> Elem a -> f (Elem b) Source #

sequenceA :: Applicative f => Elem (f a) -> f (Elem a) Source #

mapM :: Monad m => (a -> m b) -> Elem a -> m (Elem b) Source #

sequence :: Monad m => Elem (m a) -> m (Elem a) Source #

Traversable ViewL 

Methods

traverse :: Applicative f => (a -> f b) -> ViewL a -> f (ViewL b) Source #

sequenceA :: Applicative f => ViewL (f a) -> f (ViewL a) Source #

mapM :: Monad m => (a -> m b) -> ViewL a -> m (ViewL b) Source #

sequence :: Monad m => ViewL (m a) -> m (ViewL a) Source #

Traversable ViewR 

Methods

traverse :: Applicative f => (a -> f b) -> ViewR a -> f (ViewR b) Source #

sequenceA :: Applicative f => ViewR (f a) -> f (ViewR a) Source #

mapM :: Monad m => (a -> m b) -> ViewR a -> m (ViewR b) Source #

sequence :: Monad m => ViewR (m a) -> m (ViewR a) Source #

Traversable Condition # 

Methods

traverse :: Applicative f => (a -> f b) -> Condition a -> f (Condition b) Source #

sequenceA :: Applicative f => Condition (f a) -> f (Condition a) Source #

mapM :: Monad m => (a -> m b) -> Condition a -> m (Condition b) Source #

sequence :: Monad m => Condition (m a) -> m (Condition a) Source #

Traversable (Either a)

Since: 4.7.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Either a a -> f (Either a b) Source #

sequenceA :: Applicative f => Either a (f a) -> f (Either a a) Source #

mapM :: Monad m => (a -> m b) -> Either a a -> m (Either a b) Source #

sequence :: Monad m => Either a (m a) -> m (Either a a) Source #

Traversable (V1 *) 

Methods

traverse :: Applicative f => (a -> f b) -> V1 * a -> f (V1 * b) Source #

sequenceA :: Applicative f => V1 * (f a) -> f (V1 * a) Source #

mapM :: Monad m => (a -> m b) -> V1 * a -> m (V1 * b) Source #

sequence :: Monad m => V1 * (m a) -> m (V1 * a) Source #

Traversable (U1 *)

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> U1 * a -> f (U1 * b) Source #

sequenceA :: Applicative f => U1 * (f a) -> f (U1 * a) Source #

mapM :: Monad m => (a -> m b) -> U1 * a -> m (U1 * b) Source #

sequence :: Monad m => U1 * (m a) -> m (U1 * a) Source #

Traversable ((,) a)

Since: 4.7.0.0

Methods

traverse :: Applicative f => (a -> f b) -> (a, a) -> f (a, b) Source #

sequenceA :: Applicative f => (a, f a) -> f (a, a) Source #

mapM :: Monad m => (a -> m b) -> (a, a) -> m (a, b) Source #

sequence :: Monad m => (a, m a) -> m (a, a) Source #

Ix i => Traversable (Array i)

Since: 2.1

Methods

traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b) Source #

sequenceA :: Applicative f => Array i (f a) -> f (Array i a) Source #

mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b) Source #

sequence :: Monad m => Array i (m a) -> m (Array i a) Source #

Traversable (Arg a)

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Arg a a -> f (Arg a b) Source #

sequenceA :: Applicative f => Arg a (f a) -> f (Arg a a) Source #

mapM :: Monad m => (a -> m b) -> Arg a a -> m (Arg a b) Source #

sequence :: Monad m => Arg a (m a) -> m (Arg a a) Source #

Traversable (Proxy *)

Since: 4.7.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Proxy * a -> f (Proxy * b) Source #

sequenceA :: Applicative f => Proxy * (f a) -> f (Proxy * a) Source #

mapM :: Monad m => (a -> m b) -> Proxy * a -> m (Proxy * b) Source #

sequence :: Monad m => Proxy * (m a) -> m (Proxy * a) Source #

Traversable (Map k) 

Methods

traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) Source #

sequenceA :: Applicative f => Map k (f a) -> f (Map k a) Source #

mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) Source #

sequence :: Monad m => Map k (m a) -> m (Map k a) Source #

Traversable f => Traversable (Rec1 * f) 

Methods

traverse :: Applicative f => (a -> f b) -> Rec1 * f a -> f (Rec1 * f b) Source #

sequenceA :: Applicative f => Rec1 * f (f a) -> f (Rec1 * f a) Source #

mapM :: Monad m => (a -> m b) -> Rec1 * f a -> m (Rec1 * f b) Source #

sequence :: Monad m => Rec1 * f (m a) -> m (Rec1 * f a) Source #

Traversable (URec * Char) 

Methods

traverse :: Applicative f => (a -> f b) -> URec * Char a -> f (URec * Char b) Source #

sequenceA :: Applicative f => URec * Char (f a) -> f (URec * Char a) Source #

mapM :: Monad m => (a -> m b) -> URec * Char a -> m (URec * Char b) Source #

sequence :: Monad m => URec * Char (m a) -> m (URec * Char a) Source #

Traversable (URec * Double) 

Methods

traverse :: Applicative f => (a -> f b) -> URec * Double a -> f (URec * Double b) Source #

sequenceA :: Applicative f => URec * Double (f a) -> f (URec * Double a) Source #

mapM :: Monad m => (a -> m b) -> URec * Double a -> m (URec * Double b) Source #

sequence :: Monad m => URec * Double (m a) -> m (URec * Double a) Source #

Traversable (URec * Float) 

Methods

traverse :: Applicative f => (a -> f b) -> URec * Float a -> f (URec * Float b) Source #

sequenceA :: Applicative f => URec * Float (f a) -> f (URec * Float a) Source #

mapM :: Monad m => (a -> m b) -> URec * Float a -> m (URec * Float b) Source #

sequence :: Monad m => URec * Float (m a) -> m (URec * Float a) Source #

Traversable (URec * Int) 

Methods

traverse :: Applicative f => (a -> f b) -> URec * Int a -> f (URec * Int b) Source #

sequenceA :: Applicative f => URec * Int (f a) -> f (URec * Int a) Source #

mapM :: Monad m => (a -> m b) -> URec * Int a -> m (URec * Int b) Source #

sequence :: Monad m => URec * Int (m a) -> m (URec * Int a) Source #

Traversable (URec * Word) 

Methods

traverse :: Applicative f => (a -> f b) -> URec * Word a -> f (URec * Word b) Source #

sequenceA :: Applicative f => URec * Word (f a) -> f (URec * Word a) Source #

mapM :: Monad m => (a -> m b) -> URec * Word a -> m (URec * Word b) Source #

sequence :: Monad m => URec * Word (m a) -> m (URec * Word a) Source #

Traversable (URec * (Ptr ())) 

Methods

traverse :: Applicative f => (a -> f b) -> URec * (Ptr ()) a -> f (URec * (Ptr ()) b) Source #

sequenceA :: Applicative f => URec * (Ptr ()) (f a) -> f (URec * (Ptr ()) a) Source #

mapM :: Monad m => (a -> m b) -> URec * (Ptr ()) a -> m (URec * (Ptr ()) b) Source #

sequence :: Monad m => URec * (Ptr ()) (m a) -> m (URec * (Ptr ()) a) Source #

Traversable (Const * m)

Since: 4.7.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Const * m a -> f (Const * m b) Source #

sequenceA :: Applicative f => Const * m (f a) -> f (Const * m a) Source #

mapM :: Monad m => (a -> m b) -> Const * m a -> m (Const * m b) Source #

sequence :: Monad m => Const * m (m a) -> m (Const * m a) Source #

Traversable (CondBranch v c) # 

Methods

traverse :: Applicative f => (a -> f b) -> CondBranch v c a -> f (CondBranch v c b) Source #

sequenceA :: Applicative f => CondBranch v c (f a) -> f (CondBranch v c a) Source #

mapM :: Monad m => (a -> m b) -> CondBranch v c a -> m (CondBranch v c b) Source #

sequence :: Monad m => CondBranch v c (m a) -> m (CondBranch v c a) Source #

Traversable (CondTree v c) # 

Methods

traverse :: Applicative f => (a -> f b) -> CondTree v c a -> f (CondTree v c b) Source #

sequenceA :: Applicative f => CondTree v c (f a) -> f (CondTree v c a) Source #

mapM :: Monad m => (a -> m b) -> CondTree v c a -> m (CondTree v c b) Source #

sequence :: Monad m => CondTree v c (m a) -> m (CondTree v c a) Source #

Traversable (K1 * i c) 

Methods

traverse :: Applicative f => (a -> f b) -> K1 * i c a -> f (K1 * i c b) Source #

sequenceA :: Applicative f => K1 * i c (f a) -> f (K1 * i c a) Source #

mapM :: Monad m => (a -> m b) -> K1 * i c a -> m (K1 * i c b) Source #

sequence :: Monad m => K1 * i c (m a) -> m (K1 * i c a) Source #

(Traversable f, Traversable g) => Traversable ((:+:) * f g) 

Methods

traverse :: Applicative f => (a -> f b) -> (* :+: f) g a -> f ((* :+: f) g b) Source #

sequenceA :: Applicative f => (* :+: f) g (f a) -> f ((* :+: f) g a) Source #

mapM :: Monad m => (a -> m b) -> (* :+: f) g a -> m ((* :+: f) g b) Source #

sequence :: Monad m => (* :+: f) g (m a) -> m ((* :+: f) g a) Source #

(Traversable f, Traversable g) => Traversable ((:*:) * f g) 

Methods

traverse :: Applicative f => (a -> f b) -> (* :*: f) g a -> f ((* :*: f) g b) Source #

sequenceA :: Applicative f => (* :*: f) g (f a) -> f ((* :*: f) g a) Source #

mapM :: Monad m => (a -> m b) -> (* :*: f) g a -> m ((* :*: f) g b) Source #

sequence :: Monad m => (* :*: f) g (m a) -> m ((* :*: f) g a) Source #

(Traversable f, Traversable g) => Traversable (Product * f g)

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Product * f g a -> f (Product * f g b) Source #

sequenceA :: Applicative f => Product * f g (f a) -> f (Product * f g a) Source #

mapM :: Monad m => (a -> m b) -> Product * f g a -> m (Product * f g b) Source #

sequence :: Monad m => Product * f g (m a) -> m (Product * f g a) Source #

(Traversable f, Traversable g) => Traversable (Sum * f g)

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Sum * f g a -> f (Sum * f g b) Source #

sequenceA :: Applicative f => Sum * f g (f a) -> f (Sum * f g a) Source #

mapM :: Monad m => (a -> m b) -> Sum * f g a -> m (Sum * f g b) Source #

sequence :: Monad m => Sum * f g (m a) -> m (Sum * f g a) Source #

Traversable f => Traversable (M1 * i c f) 

Methods

traverse :: Applicative f => (a -> f b) -> M1 * i c f a -> f (M1 * i c f b) Source #

sequenceA :: Applicative f => M1 * i c f (f a) -> f (M1 * i c f a) Source #

mapM :: Monad m => (a -> m b) -> M1 * i c f a -> m (M1 * i c f b) Source #

sequence :: Monad m => M1 * i c f (m a) -> m (M1 * i c f a) Source #

(Traversable f, Traversable g) => Traversable ((:.:) * * f g) 

Methods

traverse :: Applicative f => (a -> f b) -> (* :.: *) f g a -> f ((* :.: *) f g b) Source #

sequenceA :: Applicative f => (* :.: *) f g (f a) -> f ((* :.: *) f g a) Source #

mapM :: Monad m => (a -> m b) -> (* :.: *) f g a -> m ((* :.: *) f g b) Source #

sequence :: Monad m => (* :.: *) f g (m a) -> m ((* :.: *) f g a) Source #

(Traversable f, Traversable g) => Traversable (Compose * * f g)

Since: 4.9.0.0

Methods

traverse :: Applicative f => (a -> f b) -> Compose * * f g a -> f (Compose * * f g b) Source #

sequenceA :: Applicative f => Compose * * f g (f a) -> f (Compose * * f g a) Source #

mapM :: Monad m => (a -> m b) -> Compose * * f g a -> m (Compose * * f g b) Source #

sequence :: Monad m => Compose * * f g (m a) -> m (Compose * * f g a) Source #

traverse :: Traversable t => forall (f :: * -> *) a b. Applicative f => (a -> f b) -> t a -> f (t b) Source #

Map each element of a structure to an action, evaluate these actions from left to right, and collect the results. For a version that ignores the results see traverse_.

sequenceA :: Traversable t => forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a) Source #

Evaluate each action in the structure from left to right, and and collect the results. For a version that ignores the results see sequenceA_.

for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) Source #

for is traverse with its arguments flipped. For a version that ignores the results see for_.

Control.Arrow

first :: Arrow a => forall b c d. a b c -> a (b, d) (c, d) Source #

Send the first component of the input through the argument arrow, and copy the rest unchanged to the output.

Control.Monad

liftM :: Monad m => (a1 -> r) -> m a1 -> m r Source #

Promote a function to a monad.

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r Source #

Promote a function to a monad, scanning the monadic arguments from left to right. For example,

   liftM2 (+) [0,1] [0,2] = [0,2,1,3]
   liftM2 (+) (Just 1) Nothing = Nothing

unless :: Applicative f => Bool -> f () -> f () Source #

The reverse of when.

when :: Applicative f => Bool -> f () -> f () Source #

Conditional execution of Applicative expressions. For example,

when debug (putStrLn "Debugging")

will output the string Debugging if the Boolean value debug is True, and otherwise do nothing.

ap :: Monad m => m (a -> b) -> m a -> m b Source #

In many situations, the liftM operations can be replaced by uses of ap, which promotes function application.

      return f `ap` x1 `ap` ... `ap` xn

is equivalent to

      liftMn f x1 x2 ... xn

void :: Functor f => f a -> f () Source #

void value discards or ignores the result of evaluation, such as the return value of an IO action.

Examples

Replace the contents of a Maybe Int with unit:

>>> void Nothing
Nothing
>>> void (Just 3)
Just ()

Replace the contents of an Either Int Int with unit, resulting in an Either Int '()':

>>> void (Left 8675309)
Left 8675309
>>> void (Right 8675309)
Right ()

Replace every element of a list with unit:

>>> void [1,2,3]
[(),(),()]

Replace the second element of a pair with unit:

>>> void (1,2)
(1,())

Discard the result of an IO action:

>>> mapM print [1,2]
1
2
[(),()]
>>> void $ mapM print [1,2]
1
2

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b Source #

The foldM function is analogous to foldl, except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue where (>>) and the `folded function' are not commutative.

      foldM f a1 [x1, x2, ..., xm]

==

      do
        a2 <- f a1 x1
        a3 <- f a2 x2
        ...
        f am xm

If right-to-left evaluation is required, the input list should be reversed.

Note: foldM is the same as foldlM

filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] Source #

This generalizes the list-based filter function.

Data.Char

isSpace :: Char -> Bool Source #

Returns True for any Unicode space character, and the control characters \t, \n, \r, \f, \v.

isDigit :: Char -> Bool Source #

Selects ASCII digits, i.e. '0'..'9'.

isUpper :: Char -> Bool Source #

Selects upper-case or title-case alphabetic Unicode characters (letters). Title case is used by a small number of letter ligatures like the single-character form of Lj.

isAlpha :: Char -> Bool Source #

Selects alphabetic Unicode characters (lower-case, upper-case and title-case letters, plus letters of caseless scripts and modifiers letters). This function is equivalent to isLetter.

isAlphaNum :: Char -> Bool Source #

Selects alphabetic or numeric digit Unicode characters.

Note that numeric digits outside the ASCII range are selected by this function but not by isDigit. Such digits may be part of identifiers but are not used by the printer and reader to represent numbers.

chr :: Int -> Char Source #

The toEnum method restricted to the type Char.

ord :: Char -> Int Source #

The fromEnum method restricted to the type Char.

toLower :: Char -> Char Source #

Convert a letter to the corresponding lower-case letter, if any. Any other character is returned unchanged.

toUpper :: Char -> Char Source #

Convert a letter to the corresponding upper-case letter, if any. Any other character is returned unchanged.

Data.Word & Data.Int

data Word :: * #

Instances

Bounded Word

Since: 2.1

Enum Word

Since: 2.1

Eq Word 

Methods

(==) :: Word -> Word -> Bool #

(/=) :: Word -> Word -> Bool #

Integral Word

Since: 2.1

Data Word

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word Source #

toConstr :: Word -> Constr Source #

dataTypeOf :: Word -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) Source #

gmapT :: (forall b. Data b => b -> b) -> Word -> Word Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word Source #

Num Word

Since: 2.1

Ord Word 

Methods

compare :: Word -> Word -> Ordering #

(<) :: Word -> Word -> Bool #

(<=) :: Word -> Word -> Bool #

(>) :: Word -> Word -> Bool #

(>=) :: Word -> Word -> Bool #

max :: Word -> Word -> Word #

min :: Word -> Word -> Word #

Read Word

Since: 4.5.0.0

Real Word

Since: 2.1

Show Word

Since: 2.1

Ix Word

Since: 4.6.0.0

Bits Word

Since: 2.1

FiniteBits Word

Since: 4.6.0.0

NFData Word 

Methods

rnf :: Word -> () Source #

Binary Word 
IArray UArray Word 

Methods

bounds :: Ix i => UArray i Word -> (i, i) Source #

numElements :: Ix i => UArray i Word -> Int

unsafeArray :: Ix i => (i, i) -> [(Int, Word)] -> UArray i Word

unsafeAt :: Ix i => UArray i Word -> Int -> Word

unsafeReplace :: Ix i => UArray i Word -> [(Int, Word)] -> UArray i Word

unsafeAccum :: Ix i => (Word -> e' -> Word) -> UArray i Word -> [(Int, e')] -> UArray i Word

unsafeAccumArray :: Ix i => (Word -> e' -> Word) -> Word -> (i, i) -> [(Int, e')] -> UArray i Word

Generic1 k (URec k Word) 

Associated Types

type Rep1 (URec k Word) (f :: URec k Word -> *) :: k -> * Source #

Methods

from1 :: f a -> Rep1 (URec k Word) f a Source #

to1 :: Rep1 (URec k Word) f a -> f a Source #

MArray (STUArray s) Word (ST s) 

Methods

getBounds :: Ix i => STUArray s i Word -> ST s (i, i) Source #

getNumElements :: Ix i => STUArray s i Word -> ST s Int

newArray :: Ix i => (i, i) -> Word -> ST s (STUArray s i Word) Source #

newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word) Source #

unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word)

unsafeRead :: Ix i => STUArray s i Word -> Int -> ST s Word

unsafeWrite :: Ix i => STUArray s i Word -> Int -> Word -> ST s ()

Functor (URec * Word) 

Methods

fmap :: (a -> b) -> URec * Word a -> URec * Word b Source #

(<$) :: a -> URec * Word b -> URec * Word a Source #

Foldable (URec * Word) 

Methods

fold :: Monoid m => URec * Word m -> m Source #

foldMap :: Monoid m => (a -> m) -> URec * Word a -> m Source #

foldr :: (a -> b -> b) -> b -> URec * Word a -> b Source #

foldr' :: (a -> b -> b) -> b -> URec * Word a -> b Source #

foldl :: (b -> a -> b) -> b -> URec * Word a -> b Source #

foldl' :: (b -> a -> b) -> b -> URec * Word a -> b Source #

foldr1 :: (a -> a -> a) -> URec * Word a -> a Source #

foldl1 :: (a -> a -> a) -> URec * Word a -> a Source #

toList :: URec * Word a -> [a] Source #

null :: URec * Word a -> Bool Source #

length :: URec * Word a -> Int Source #

elem :: Eq a => a -> URec * Word a -> Bool Source #

maximum :: Ord a => URec * Word a -> a Source #

minimum :: Ord a => URec * Word a -> a Source #

sum :: Num a => URec * Word a -> a Source #

product :: Num a => URec * Word a -> a Source #

Traversable (URec * Word) 

Methods

traverse :: Applicative f => (a -> f b) -> URec * Word a -> f (URec * Word b) Source #

sequenceA :: Applicative f => URec * Word (f a) -> f (URec * Word a) Source #

mapM :: Monad m => (a -> m b) -> URec * Word a -> m (URec * Word b) Source #

sequence :: Monad m => URec * Word (m a) -> m (URec * Word a) Source #

Eq (URec k Word p) 

Methods

(==) :: URec k Word p -> URec k Word p -> Bool #

(/=) :: URec k Word p -> URec k Word p -> Bool #

Ord (URec k Word p) 

Methods

compare :: URec k Word p -> URec k Word p -> Ordering #

(<) :: URec k Word p -> URec k Word p -> Bool #

(<=) :: URec k Word p -> URec k Word p -> Bool #

(>) :: URec k Word p -> URec k Word p -> Bool #

(>=) :: URec k Word p -> URec k Word p -> Bool #

max :: URec k Word p -> URec k Word p -> URec k Word p #

min :: URec k Word p -> URec k Word p -> URec k Word p #

Show (URec k Word p) 

Methods

showsPrec :: Int -> URec k Word p -> ShowS Source #

show :: URec k Word p -> String Source #

showList :: [URec k Word p] -> ShowS Source #

Generic (URec k Word p) 

Associated Types

type Rep (URec k Word p) :: * -> * Source #

Methods

from :: URec k Word p -> Rep (URec k Word p) x Source #

to :: Rep (URec k Word p) x -> URec k Word p Source #

data URec k Word

Used for marking occurrences of Word#

Since: 4.9.0.0

data URec k Word = UWord {}
type Rep1 k (URec k Word) 
type Rep1 k (URec k Word) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UWord" PrefixI True) (S1 k (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord k)))
type Rep (URec k Word p) 
type Rep (URec k Word p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UWord" PrefixI True) (S1 * (MetaSel (Just Symbol "uWord#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UWord *)))

data Word8 :: * Source #

8-bit unsigned integer type

Instances

Bounded Word8

Since: 2.1

Enum Word8

Since: 2.1

Eq Word8

Since: 2.1

Methods

(==) :: Word8 -> Word8 -> Bool #

(/=) :: Word8 -> Word8 -> Bool #

Integral Word8

Since: 2.1

Data Word8

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word8 -> c Word8 Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word8 Source #

toConstr :: Word8 -> Constr Source #

dataTypeOf :: Word8 -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word8) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word8) Source #

gmapT :: (forall b. Data b => b -> b) -> Word8 -> Word8 Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word8 -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Word8 -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word8 -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word8 -> m Word8 Source #

Num Word8

Since: 2.1

Ord Word8

Since: 2.1

Methods

compare :: Word8 -> Word8 -> Ordering #

(<) :: Word8 -> Word8 -> Bool #

(<=) :: Word8 -> Word8 -> Bool #

(>) :: Word8 -> Word8 -> Bool #

(>=) :: Word8 -> Word8 -> Bool #

max :: Word8 -> Word8 -> Word8 #

min :: Word8 -> Word8 -> Word8 #

Read Word8

Since: 2.1

Real Word8

Since: 2.1

Show Word8

Since: 2.1

Ix Word8

Since: 2.1

Bits Word8

Since: 2.1

FiniteBits Word8

Since: 4.6.0.0

NFData Word8 

Methods

rnf :: Word8 -> () Source #

Binary Word8 
IArray UArray Word8 

Methods

bounds :: Ix i => UArray i Word8 -> (i, i) Source #

numElements :: Ix i => UArray i Word8 -> Int

unsafeArray :: Ix i => (i, i) -> [(Int, Word8)] -> UArray i Word8

unsafeAt :: Ix i => UArray i Word8 -> Int -> Word8

unsafeReplace :: Ix i => UArray i Word8 -> [(Int, Word8)] -> UArray i Word8

unsafeAccum :: Ix i => (Word8 -> e' -> Word8) -> UArray i Word8 -> [(Int, e')] -> UArray i Word8

unsafeAccumArray :: Ix i => (Word8 -> e' -> Word8) -> Word8 -> (i, i) -> [(Int, e')] -> UArray i Word8

MArray (STUArray s) Word8 (ST s) 

Methods

getBounds :: Ix i => STUArray s i Word8 -> ST s (i, i) Source #

getNumElements :: Ix i => STUArray s i Word8 -> ST s Int

newArray :: Ix i => (i, i) -> Word8 -> ST s (STUArray s i Word8) Source #

newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word8) Source #

unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word8)

unsafeRead :: Ix i => STUArray s i Word8 -> Int -> ST s Word8

unsafeWrite :: Ix i => STUArray s i Word8 -> Int -> Word8 -> ST s ()

data Word16 :: * Source #

16-bit unsigned integer type

Instances

Bounded Word16

Since: 2.1

Enum Word16

Since: 2.1

Eq Word16

Since: 2.1

Methods

(==) :: Word16 -> Word16 -> Bool #

(/=) :: Word16 -> Word16 -> Bool #

Integral Word16

Since: 2.1

Data Word16

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word16 -> c Word16 Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word16 Source #

toConstr :: Word16 -> Constr Source #

dataTypeOf :: Word16 -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word16) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word16) Source #

gmapT :: (forall b. Data b => b -> b) -> Word16 -> Word16 Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word16 -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Word16 -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word16 -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word16 -> m Word16 Source #

Num Word16

Since: 2.1

Ord Word16

Since: 2.1

Read Word16

Since: 2.1

Real Word16

Since: 2.1

Show Word16

Since: 2.1

Ix Word16

Since: 2.1

Bits Word16

Since: 2.1

FiniteBits Word16

Since: 4.6.0.0

NFData Word16 

Methods

rnf :: Word16 -> () Source #

Binary Word16 
IArray UArray Word16 

Methods

bounds :: Ix i => UArray i Word16 -> (i, i) Source #

numElements :: Ix i => UArray i Word16 -> Int

unsafeArray :: Ix i => (i, i) -> [(Int, Word16)] -> UArray i Word16

unsafeAt :: Ix i => UArray i Word16 -> Int -> Word16

unsafeReplace :: Ix i => UArray i Word16 -> [(Int, Word16)] -> UArray i Word16

unsafeAccum :: Ix i => (Word16 -> e' -> Word16) -> UArray i Word16 -> [(Int, e')] -> UArray i Word16

unsafeAccumArray :: Ix i => (Word16 -> e' -> Word16) -> Word16 -> (i, i) -> [(Int, e')] -> UArray i Word16

MArray (STUArray s) Word16 (ST s) 

Methods

getBounds :: Ix i => STUArray s i Word16 -> ST s (i, i) Source #

getNumElements :: Ix i => STUArray s i Word16 -> ST s Int

newArray :: Ix i => (i, i) -> Word16 -> ST s (STUArray s i Word16) Source #

newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word16) Source #

unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word16)

unsafeRead :: Ix i => STUArray s i Word16 -> Int -> ST s Word16

unsafeWrite :: Ix i => STUArray s i Word16 -> Int -> Word16 -> ST s ()

data Word32 :: * Source #

32-bit unsigned integer type

Instances

Bounded Word32

Since: 2.1

Enum Word32

Since: 2.1

Eq Word32

Since: 2.1

Methods

(==) :: Word32 -> Word32 -> Bool #

(/=) :: Word32 -> Word32 -> Bool #

Integral Word32

Since: 2.1

Data Word32

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word32 -> c Word32 Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word32 Source #

toConstr :: Word32 -> Constr Source #

dataTypeOf :: Word32 -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word32) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word32) Source #

gmapT :: (forall b. Data b => b -> b) -> Word32 -> Word32 Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word32 -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Word32 -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word32 -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word32 -> m Word32 Source #

Num Word32

Since: 2.1

Ord Word32

Since: 2.1

Read Word32

Since: 2.1

Real Word32

Since: 2.1

Show Word32

Since: 2.1

Ix Word32

Since: 2.1

Bits Word32

Since: 2.1

FiniteBits Word32

Since: 4.6.0.0

NFData Word32 

Methods

rnf :: Word32 -> () Source #

Binary Word32 
IArray UArray Word32 

Methods

bounds :: Ix i => UArray i Word32 -> (i, i) Source #

numElements :: Ix i => UArray i Word32 -> Int

unsafeArray :: Ix i => (i, i) -> [(Int, Word32)] -> UArray i Word32

unsafeAt :: Ix i => UArray i Word32 -> Int -> Word32

unsafeReplace :: Ix i => UArray i Word32 -> [(Int, Word32)] -> UArray i Word32

unsafeAccum :: Ix i => (Word32 -> e' -> Word32) -> UArray i Word32 -> [(Int, e')] -> UArray i Word32

unsafeAccumArray :: Ix i => (Word32 -> e' -> Word32) -> Word32 -> (i, i) -> [(Int, e')] -> UArray i Word32

MArray (STUArray s) Word32 (ST s) 

Methods

getBounds :: Ix i => STUArray s i Word32 -> ST s (i, i) Source #

getNumElements :: Ix i => STUArray s i Word32 -> ST s Int

newArray :: Ix i => (i, i) -> Word32 -> ST s (STUArray s i Word32) Source #

newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word32) Source #

unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word32)

unsafeRead :: Ix i => STUArray s i Word32 -> Int -> ST s Word32

unsafeWrite :: Ix i => STUArray s i Word32 -> Int -> Word32 -> ST s ()

data Word64 :: * Source #

64-bit unsigned integer type

Instances

Bounded Word64

Since: 2.1

Enum Word64

Since: 2.1

Eq Word64

Since: 2.1

Methods

(==) :: Word64 -> Word64 -> Bool #

(/=) :: Word64 -> Word64 -> Bool #

Integral Word64

Since: 2.1

Data Word64

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word64 -> c Word64 Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word64 Source #

toConstr :: Word64 -> Constr Source #

dataTypeOf :: Word64 -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Word64) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word64) Source #

gmapT :: (forall b. Data b => b -> b) -> Word64 -> Word64 Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word64 -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Word64 -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Word64 -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word64 -> m Word64 Source #

Num Word64

Since: 2.1

Ord Word64

Since: 2.1

Read Word64

Since: 2.1

Real Word64

Since: 2.1

Show Word64

Since: 2.1

Ix Word64

Since: 2.1

Bits Word64

Since: 2.1

FiniteBits Word64

Since: 4.6.0.0

NFData Word64 

Methods

rnf :: Word64 -> () Source #

Binary Word64 
IArray UArray Word64 

Methods

bounds :: Ix i => UArray i Word64 -> (i, i) Source #

numElements :: Ix i => UArray i Word64 -> Int

unsafeArray :: Ix i => (i, i) -> [(Int, Word64)] -> UArray i Word64

unsafeAt :: Ix i => UArray i Word64 -> Int -> Word64

unsafeReplace :: Ix i => UArray i Word64 -> [(Int, Word64)] -> UArray i Word64

unsafeAccum :: Ix i => (Word64 -> e' -> Word64) -> UArray i Word64 -> [(Int, e')] -> UArray i Word64

unsafeAccumArray :: Ix i => (Word64 -> e' -> Word64) -> Word64 -> (i, i) -> [(Int, e')] -> UArray i Word64

MArray (STUArray s) Word64 (ST s) 

Methods

getBounds :: Ix i => STUArray s i Word64 -> ST s (i, i) Source #

getNumElements :: Ix i => STUArray s i Word64 -> ST s Int

newArray :: Ix i => (i, i) -> Word64 -> ST s (STUArray s i Word64) Source #

newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word64) Source #

unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word64)

unsafeRead :: Ix i => STUArray s i Word64 -> Int -> ST s Word64

unsafeWrite :: Ix i => STUArray s i Word64 -> Int -> Word64 -> ST s ()

data Int8 :: * Source #

8-bit signed integer type

Instances

Bounded Int8

Since: 2.1

Enum Int8

Since: 2.1

Eq Int8

Since: 2.1

Methods

(==) :: Int8 -> Int8 -> Bool #

(/=) :: Int8 -> Int8 -> Bool #

Integral Int8

Since: 2.1

Data Int8

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int8 -> c Int8 Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int8 Source #

toConstr :: Int8 -> Constr Source #

dataTypeOf :: Int8 -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int8) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int8) Source #

gmapT :: (forall b. Data b => b -> b) -> Int8 -> Int8 Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int8 -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Int8 -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int8 -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int8 -> m Int8 Source #

Num Int8

Since: 2.1

Ord Int8

Since: 2.1

Methods

compare :: Int8 -> Int8 -> Ordering #

(<) :: Int8 -> Int8 -> Bool #

(<=) :: Int8 -> Int8 -> Bool #

(>) :: Int8 -> Int8 -> Bool #

(>=) :: Int8 -> Int8 -> Bool #

max :: Int8 -> Int8 -> Int8 #

min :: Int8 -> Int8 -> Int8 #

Read Int8

Since: 2.1

Real Int8

Since: 2.1

Show Int8

Since: 2.1

Ix Int8

Since: 2.1

Bits Int8

Since: 2.1

FiniteBits Int8

Since: 4.6.0.0

NFData Int8 

Methods

rnf :: Int8 -> () Source #

Binary Int8 
IArray UArray Int8 

Methods

bounds :: Ix i => UArray i Int8 -> (i, i) Source #

numElements :: Ix i => UArray i Int8 -> Int

unsafeArray :: Ix i => (i, i) -> [(Int, Int8)] -> UArray i Int8

unsafeAt :: Ix i => UArray i Int8 -> Int -> Int8

unsafeReplace :: Ix i => UArray i Int8 -> [(Int, Int8)] -> UArray i Int8

unsafeAccum :: Ix i => (Int8 -> e' -> Int8) -> UArray i Int8 -> [(Int, e')] -> UArray i Int8

unsafeAccumArray :: Ix i => (Int8 -> e' -> Int8) -> Int8 -> (i, i) -> [(Int, e')] -> UArray i Int8

MArray (STUArray s) Int8 (ST s) 

Methods

getBounds :: Ix i => STUArray s i Int8 -> ST s (i, i) Source #

getNumElements :: Ix i => STUArray s i Int8 -> ST s Int

newArray :: Ix i => (i, i) -> Int8 -> ST s (STUArray s i Int8) Source #

newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int8) Source #

unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int8)

unsafeRead :: Ix i => STUArray s i Int8 -> Int -> ST s Int8

unsafeWrite :: Ix i => STUArray s i Int8 -> Int -> Int8 -> ST s ()

data Int16 :: * Source #

16-bit signed integer type

Instances

Bounded Int16

Since: 2.1

Enum Int16

Since: 2.1

Eq Int16

Since: 2.1

Methods

(==) :: Int16 -> Int16 -> Bool #

(/=) :: Int16 -> Int16 -> Bool #

Integral Int16

Since: 2.1

Data Int16

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int16 -> c Int16 Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int16 Source #

toConstr :: Int16 -> Constr Source #

dataTypeOf :: Int16 -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int16) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int16) Source #

gmapT :: (forall b. Data b => b -> b) -> Int16 -> Int16 Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int16 -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Int16 -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int16 -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int16 -> m Int16 Source #

Num Int16

Since: 2.1

Ord Int16

Since: 2.1

Methods

compare :: Int16 -> Int16 -> Ordering #

(<) :: Int16 -> Int16 -> Bool #

(<=) :: Int16 -> Int16 -> Bool #

(>) :: Int16 -> Int16 -> Bool #

(>=) :: Int16 -> Int16 -> Bool #

max :: Int16 -> Int16 -> Int16 #

min :: Int16 -> Int16 -> Int16 #

Read Int16

Since: 2.1

Real Int16

Since: 2.1

Show Int16

Since: 2.1

Ix Int16

Since: 2.1

Bits Int16

Since: 2.1

FiniteBits Int16

Since: 4.6.0.0

NFData Int16 

Methods

rnf :: Int16 -> () Source #

Binary Int16 
IArray UArray Int16 

Methods

bounds :: Ix i => UArray i Int16 -> (i, i) Source #

numElements :: Ix i => UArray i Int16 -> Int

unsafeArray :: Ix i => (i, i) -> [(Int, Int16)] -> UArray i Int16

unsafeAt :: Ix i => UArray i Int16 -> Int -> Int16

unsafeReplace :: Ix i => UArray i Int16 -> [(Int, Int16)] -> UArray i Int16

unsafeAccum :: Ix i => (Int16 -> e' -> Int16) -> UArray i Int16 -> [(Int, e')] -> UArray i Int16

unsafeAccumArray :: Ix i => (Int16 -> e' -> Int16) -> Int16 -> (i, i) -> [(Int, e')] -> UArray i Int16

MArray (STUArray s) Int16 (ST s) 

Methods

getBounds :: Ix i => STUArray s i Int16 -> ST s (i, i) Source #

getNumElements :: Ix i => STUArray s i Int16 -> ST s Int

newArray :: Ix i => (i, i) -> Int16 -> ST s (STUArray s i Int16) Source #

newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int16) Source #

unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int16)

unsafeRead :: Ix i => STUArray s i Int16 -> Int -> ST s Int16

unsafeWrite :: Ix i => STUArray s i Int16 -> Int -> Int16 -> ST s ()

data Int32 :: * Source #

32-bit signed integer type

Instances

Bounded Int32

Since: 2.1

Enum Int32

Since: 2.1

Eq Int32

Since: 2.1

Methods

(==) :: Int32 -> Int32 -> Bool #

(/=) :: Int32 -> Int32 -> Bool #

Integral Int32

Since: 2.1

Data Int32

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int32 -> c Int32 Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int32 Source #

toConstr :: Int32 -> Constr Source #

dataTypeOf :: Int32 -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int32) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int32) Source #

gmapT :: (forall b. Data b => b -> b) -> Int32 -> Int32 Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int32 -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Int32 -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int32 -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int32 -> m Int32 Source #

Num Int32

Since: 2.1

Ord Int32

Since: 2.1

Methods

compare :: Int32 -> Int32 -> Ordering #

(<) :: Int32 -> Int32 -> Bool #

(<=) :: Int32 -> Int32 -> Bool #

(>) :: Int32 -> Int32 -> Bool #

(>=) :: Int32 -> Int32 -> Bool #

max :: Int32 -> Int32 -> Int32 #

min :: Int32 -> Int32 -> Int32 #

Read Int32

Since: 2.1

Real Int32

Since: 2.1

Show Int32

Since: 2.1

Ix Int32

Since: 2.1

Bits Int32

Since: 2.1

FiniteBits Int32

Since: 4.6.0.0

NFData Int32 

Methods

rnf :: Int32 -> () Source #

Binary Int32 
IArray UArray Int32 

Methods

bounds :: Ix i => UArray i Int32 -> (i, i) Source #

numElements :: Ix i => UArray i Int32 -> Int

unsafeArray :: Ix i => (i, i) -> [(Int, Int32)] -> UArray i Int32

unsafeAt :: Ix i => UArray i Int32 -> Int -> Int32

unsafeReplace :: Ix i => UArray i Int32 -> [(Int, Int32)] -> UArray i Int32

unsafeAccum :: Ix i => (Int32 -> e' -> Int32) -> UArray i Int32 -> [(Int, e')] -> UArray i Int32

unsafeAccumArray :: Ix i => (Int32 -> e' -> Int32) -> Int32 -> (i, i) -> [(Int, e')] -> UArray i Int32

MArray (STUArray s) Int32 (ST s) 

Methods

getBounds :: Ix i => STUArray s i Int32 -> ST s (i, i) Source #

getNumElements :: Ix i => STUArray s i Int32 -> ST s Int

newArray :: Ix i => (i, i) -> Int32 -> ST s (STUArray s i Int32) Source #

newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int32) Source #

unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int32)

unsafeRead :: Ix i => STUArray s i Int32 -> Int -> ST s Int32

unsafeWrite :: Ix i => STUArray s i Int32 -> Int -> Int32 -> ST s ()

data Int64 :: * Source #

64-bit signed integer type

Instances

Bounded Int64

Since: 2.1

Enum Int64

Since: 2.1

Eq Int64

Since: 2.1

Methods

(==) :: Int64 -> Int64 -> Bool #

(/=) :: Int64 -> Int64 -> Bool #

Integral Int64

Since: 2.1

Data Int64

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int64 -> c Int64 Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int64 Source #

toConstr :: Int64 -> Constr Source #

dataTypeOf :: Int64 -> DataType Source #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Int64) Source #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int64) Source #

gmapT :: (forall b. Data b => b -> b) -> Int64 -> Int64 Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r Source #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int64 -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Int64 -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Int64 -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int64 -> m Int64 Source #

Num Int64

Since: 2.1

Ord Int64

Since: 2.1

Methods

compare :: Int64 -> Int64 -> Ordering #

(<) :: Int64 -> Int64 -> Bool #

(<=) :: Int64 -> Int64 -> Bool #

(>) :: Int64 -> Int64 -> Bool #

(>=) :: Int64 -> Int64 -> Bool #

max :: Int64 -> Int64 -> Int64 #

min :: Int64 -> Int64 -> Int64 #

Read Int64

Since: 2.1

Real Int64

Since: 2.1

Show Int64

Since: 2.1

Ix Int64

Since: 2.1

Bits Int64

Since: 2.1

FiniteBits Int64

Since: 4.6.0.0

NFData Int64 

Methods

rnf :: Int64 -> () Source #

Binary Int64 
IArray UArray Int64 

Methods

bounds :: Ix i => UArray i Int64 -> (i, i) Source #

numElements :: Ix i => UArray i Int64 -> Int

unsafeArray :: Ix i => (i, i) -> [(Int, Int64)] -> UArray i Int64

unsafeAt :: Ix i => UArray i Int64 -> Int -> Int64

unsafeReplace :: Ix i => UArray i Int64 -> [(Int, Int64)] -> UArray i Int64

unsafeAccum :: Ix i => (Int64 -> e' -> Int64) -> UArray i Int64 -> [(Int, e')] -> UArray i Int64

unsafeAccumArray :: Ix i => (Int64 -> e' -> Int64) -> Int64 -> (i, i) -> [(Int, e')] -> UArray i Int64

MArray (STUArray s) Int64 (ST s) 

Methods

getBounds :: Ix i => STUArray s i Int64 -> ST s (i, i) Source #

getNumElements :: Ix i => STUArray s i Int64 -> ST s Int

newArray :: Ix i => (i, i) -> Int64 -> ST s (STUArray s i Int64) Source #

newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int64) Source #

unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int64)

unsafeRead :: Ix i => STUArray s i Int64 -> Int -> ST s Int64

unsafeWrite :: Ix i => STUArray s i Int64 -> Int -> Int64 -> ST s ()

Text.PrettyPrint

(<<>>) :: Doc -> Doc -> Doc Source #

New name for <>