Copyright	(c) Universiteit Utrecht 2010-2011 University of Oxford 2012-2014
License	see libraries/base/LICENSE
Maintainer	libraries@haskell.org
Stability	internal
Portability	non-portable
Safe Haskell	Trustworthy
Language	Haskell2010

GHC.Generics

Contents

Introduction
Generic representation types
- Unboxed representation types
- Synonyms for convenience
Meta-information
Generic type classes

Description

If you're using GHC.Generics, you should consider using the http://hackage.haskell.org/package/generic-deriving package, which contains many useful generic functions.

Since: base-4.6.0.0

Synopsis

data V1 (p :: k)
data U1 (p :: k) = U1
newtype Par1 p = Par1 {
- unPar1 :: p
}
newtype Rec1 (f :: k -> Type) (p :: k) = Rec1 {
- unRec1 :: f p
}
newtype K1 (i :: Type) c (p :: k) = K1 {
- unK1 :: c
}
newtype M1 (i :: Type) (c :: Meta) (f :: k -> Type) (p :: k) = M1 {
- unM1 :: f p
}
data ((f :: k -> Type) :+: (g :: k -> Type)) (p :: k)
- = L1 (f p)
- | R1 (g p)
data ((f :: k -> Type) :*: (g :: k -> Type)) (p :: k) = (f p) :*: (g p)
newtype ((f :: k2 -> Type) :.: (g :: k1 -> k2)) (p :: k1) = Comp1 {
- unComp1 :: f (g p)
}
data family URec (a :: Type) (p :: k)
type UAddr = URec (Ptr ())
type UChar = URec Char
type UDouble = URec Double
type UFloat = URec Float
type UInt = URec Int
type UWord = URec Word
type Rec0 = K1 R
data R
type D1 = M1 D
type C1 = M1 C
type S1 = M1 S
data D
data C
data S
class Datatype d where
- datatypeName :: t d (f :: k -> Type) (a :: k) -> [Char]
- moduleName :: t d (f :: k -> Type) (a :: k) -> [Char]
- packageName :: t d (f :: k -> Type) (a :: k) -> [Char]
- isNewtype :: t d (f :: k -> Type) (a :: k) -> Bool
class Constructor c where
- conName :: t c (f :: k -> Type) (a :: k) -> [Char]
- conFixity :: t c (f :: k -> Type) (a :: k) -> Fixity
- conIsRecord :: t c (f :: k -> Type) (a :: k) -> Bool
class Selector s where
- selName :: t s (f :: k -> Type) (a :: k) -> [Char]
- selSourceUnpackedness :: t s (f :: k -> Type) (a :: k) -> SourceUnpackedness
- selSourceStrictness :: t s (f :: k -> Type) (a :: k) -> SourceStrictness
- selDecidedStrictness :: t s (f :: k -> Type) (a :: k) -> DecidedStrictness
data Fixity
- = Prefix
- | Infix Associativity Int
data FixityI
- = PrefixI
- | InfixI Associativity Nat
data Associativity
- = LeftAssociative
- | RightAssociative
- | NotAssociative
prec :: Fixity -> Int
data SourceUnpackedness
- = NoSourceUnpackedness
- | SourceNoUnpack
- | SourceUnpack
data SourceStrictness
- = NoSourceStrictness
- | SourceLazy
- | SourceStrict
data DecidedStrictness
- = DecidedLazy
- | DecidedStrict
- | DecidedUnpack
data Meta
- = MetaData Symbol Symbol Symbol Bool
- | MetaCons Symbol FixityI Bool
- | MetaSel (Maybe Symbol) SourceUnpackedness SourceStrictness DecidedStrictness
class Generic a where
- type Rep a :: Type -> Type
- from :: a -> Rep a x
- to :: Rep a x -> a
class Generic1 (f :: k -> Type) where
- type Rep1 f :: k -> Type
- from1 :: f a -> Rep1 f a
- to1 :: Rep1 f a -> f a

Introduction

Datatype-generic functions are based on the idea of converting values of a datatype T into corresponding values of a (nearly) isomorphic type Rep T. The type Rep T is built from a limited set of type constructors, all provided by this module. A datatype-generic function is then an overloaded function with instances for most of these type constructors, together with a wrapper that performs the mapping between T and Rep T. By using this technique, we merely need a few generic instances in order to implement functionality that works for any representable type.

Representable types are collected in the Generic class, which defines the associated type Rep as well as conversion functions from and to. Typically, you will not define Generic instances by hand, but have the compiler derive them for you.

Representing datatypes

The key to defining your own datatype-generic functions is to understand how to represent datatypes using the given set of type constructors.

Let us look at an example first:

data Tree a = Leaf a | Node (Tree a) (Tree a)
  deriving Generic

The above declaration (which requires the language pragma DeriveGeneric) causes the following representation to be generated:

instance Generic (Tree a) where
  type Rep (Tree a) =
    D1 ('MetaData "Tree" "Main" "package-name" 'False)
      (C1 ('MetaCons "Leaf" 'PrefixI 'False)
         (S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
                (Rec0 a))
       :+:
       C1 ('MetaCons "Node" 'PrefixI 'False)
         (S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               (Rec0 (Tree a))
          :*:
          S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               (Rec0 (Tree a))))
  ...

Hint: You can obtain information about the code being generated from GHC by passing the -ddump-deriv flag. In GHCi, you can expand a type family such as Rep using the :kind! command.

This is a lot of information! However, most of it is actually merely meta-information that makes names of datatypes and constructors and more available on the type level.

Here is a reduced representation for Tree with nearly all meta-information removed, for now keeping only the most essential aspects:

instance Generic (Tree a) where
  type Rep (Tree a) =
    Rec0 a
    :+:
    (Rec0 (Tree a) :*: Rec0 (Tree a))

The Tree datatype has two constructors. The representation of individual constructors is combined using the binary type constructor :+:.

The first constructor consists of a single field, which is the parameter a. This is represented as Rec0 a.

The second constructor consists of two fields. Each is a recursive field of type Tree a, represented as Rec0 (Tree a). Representations of individual fields are combined using the binary type constructor :*:.

Now let us explain the additional tags being used in the complete representation:

The S1 ('MetaSel 'Nothing 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) tag indicates several things. The 'Nothing indicates that there is no record field selector associated with this field of the constructor (if there were, it would have been marked 'Just "recordName" instead). The other types contain meta-information on the field's strictness:
There is no {-# UNPACK #-} or {-# NOUNPACK #-} annotation in the source, so it is tagged with 'NoSourceUnpackedness.
There is no strictness (!) or laziness (~) annotation in the source, so it is tagged with 'NoSourceStrictness.
The compiler infers that the field is lazy, so it is tagged with 'DecidedLazy. Bear in mind that what the compiler decides may be quite different from what is written in the source. See DecidedStrictness for a more detailed explanation.

The 'MetaSel type is also an instance of the type class Selector, which can be used to obtain information about the field at the value level.

The C1 ('MetaCons "Leaf" 'PrefixI 'False) and C1 ('MetaCons "Node" 'PrefixI 'False) invocations indicate that the enclosed part is the representation of the first and second constructor of datatype Tree, respectively. Here, the meta-information regarding constructor names, fixity and whether it has named fields or not is encoded at the type level. The 'MetaCons type is also an instance of the type class Constructor. This type class can be used to obtain information about the constructor at the value level.
The D1 ('MetaData "Tree" "Main" "package-name" 'False) tag indicates that the enclosed part is the representation of the datatype Tree. Again, the meta-information is encoded at the type level. The 'MetaData type is an instance of class Datatype, which can be used to obtain the name of a datatype, the module it has been defined in, the package it is located under, and whether it has been defined using data or newtype at the value level.

Derived and fundamental representation types

There are many datatype-generic functions that do not distinguish between positions that are parameters or positions that are recursive calls. There are also many datatype-generic functions that do not care about the names of datatypes and constructors at all. To keep the number of cases to consider in generic functions in such a situation to a minimum, it turns out that many of the type constructors introduced above are actually synonyms, defining them to be variants of a smaller set of constructors.

Individual fields of constructors: `K1`

The type constructor Rec0 is a variant of K1:

type Rec0 = K1 R

Here, R is a type-level proxy that does not have any associated values.

There used to be another variant of K1 (namely Par0), but it has since been deprecated.

Meta information: `M1`

The type constructors S1, C1 and D1 are all variants of M1:

type S1 = M1 S
type C1 = M1 C
type D1 = M1 D

The types S, C and D are once again type-level proxies, just used to create several variants of M1.

Additional generic representation type constructors

Next to K1, M1, :+: and :*: there are a few more type constructors that occur in the representations of other datatypes.

Empty datatypes: `V1`

For empty datatypes, V1 is used as a representation. For example,

data Empty deriving Generic

yields

instance Generic Empty where
  type Rep Empty =
    D1 ('MetaData "Empty" "Main" "package-name" 'False) V1

Constructors without fields: `U1`

If a constructor has no arguments, then U1 is used as its representation. For example the representation of Bool is

instance Generic Bool where
  type Rep Bool =
    D1 ('MetaData "Bool" "Data.Bool" "package-name" 'False)
      (C1 ('MetaCons "False" 'PrefixI 'False) U1 :+: C1 ('MetaCons "True" 'PrefixI 'False) U1)

Representation of types with many constructors or many fields

As :+: and :*: are just binary operators, one might ask what happens if the datatype has more than two constructors, or a constructor with more than two fields. The answer is simple: the operators are used several times, to combine all the constructors and fields as needed. However, users /should not rely on a specific nesting strategy/ for :+: and :*: being used. The compiler is free to choose any nesting it prefers. (In practice, the current implementation tries to produce a more-or-less balanced nesting, so that the traversal of the structure of the datatype from the root to a particular component can be performed in logarithmic rather than linear time.)

Defining datatype-generic functions

A datatype-generic function comprises two parts:

Generic instances for the function, implementing it for most of the representation type constructors introduced above.
A wrapper that for any datatype that is in Generic, performs the conversion between the original value and its Rep-based representation and then invokes the generic instances.

As an example, let us look at a function encode that produces a naive, but lossless bit encoding of values of various datatypes. So we are aiming to define a function

encode :: Generic a => a -> [Bool]

where we use Bool as our datatype for bits.

For part 1, we define a class Encode'. Perhaps surprisingly, this class is parameterized over a type constructor f of kind * -> *. This is a technicality: all the representation type constructors operate with kind * -> * as base kind. But the type argument is never being used. This may be changed at some point in the future. The class has a single method, and we use the type we want our final function to have, but we replace the occurrences of the generic type argument a with f p (where the p is any argument; it will not be used).

class Encode' f where
  encode' :: f p -> [Bool]

With the goal in mind to make encode work on Tree and other datatypes, we now define instances for the representation type constructors V1, U1, :+:, :*:, K1, and M1.

Definition of the generic representation types

In order to be able to do this, we need to know the actual definitions of these types:

data    V1        p                       -- lifted version of Empty
data    U1        p = U1                  -- lifted version of ()
data    (:+:) f g p = L1 (f p) | R1 (g p) -- lifted version of Either
data    (:*:) f g p = (f p) :*: (g p)     -- lifted version of (,)
newtype K1    i c p = K1 { unK1 :: c }    -- a container for a c
newtype M1  i t f p = M1 { unM1 :: f p }  -- a wrapper

So, U1 is just the unit type, :+: is just a binary choice like Either, :*: is a binary pair like the pair constructor (,), and K1 is a value of a specific type c, and M1 wraps a value of the generic type argument, which in the lifted world is an f p (where we do not care about p).

Generic instances

To deal with the V1 case, we use the following code (which requires the pragma EmptyCase):

instance Encode' V1 where
  encode' x = case x of { }

There are no values of type V1 p to pass, so it is impossible for this function to be invoked. One can ask why it is useful to define an instance for V1 at all in this case? Well, an empty type can be used as an argument to a non-empty type, and you might still want to encode the resulting type. As a somewhat contrived example, consider [Empty], which is not an empty type, but contains just the empty list. The V1 instance ensures that we can call the generic function on such types.

There is exactly one value of type U1, so encoding it requires no knowledge, and we can use zero bits:

instance Encode' U1 where
  encode' U1 = []

In the case for :+:, we produce False or True depending on whether the constructor of the value provided is located on the left or on the right:

instance (Encode' f, Encode' g) => Encode' (f :+: g) where
  encode' (L1 x) = False : encode' x
  encode' (R1 x) = True  : encode' x

(Note that this encoding strategy may not be reliable across different versions of GHC. Recall that the compiler is free to choose any nesting of :+: it chooses, so if GHC chooses (a :+: b) :+: c, then the encoding for a would be [False, False], b would be [False, True], and c would be [True]. However, if GHC chooses a :+: (b :+: c), then the encoding for a would be [False], b would be [True, False], and c would be [True, True].)

In the case for :*:, we append the encodings of the two subcomponents:

instance (Encode' f, Encode' g) => Encode' (f :*: g) where
  encode' (x :*: y) = encode' x ++ encode' y

The case for K1 is rather interesting. Here, we call the final function encode that we yet have to define, recursively. We will use another type class Encode for that function:

instance (Encode c) => Encode' (K1 i c) where
  encode' (K1 x) = encode x

Note how we can define a uniform instance for M1, because we completely disregard all meta-information:

instance (Encode' f) => Encode' (M1 i t f) where
  encode' (M1 x) = encode' x

Unlike in K1, the instance for M1 refers to encode', not encode.

The wrapper and generic default

We now define class Encode for the actual encode function:

class Encode a where
  encode :: a -> [Bool]
  default encode :: (Generic a, Encode' (Rep a)) => a -> [Bool]
  encode x = encode' (from x)

The incoming x is converted using from, then we dispatch to the generic instances using encode'. We use this as a default definition for encode. We need the default encode signature because ordinary Haskell default methods must not introduce additional class constraints, but our generic default does.

Defining a particular instance is now as simple as saying

instance (Encode a) => Encode (Tree a)

Omitting generic instances

It is not always required to provide instances for all the generic representation types, but omitting instances restricts the set of datatypes the functions will work for:

If no :+: instance is given, the function may still work for empty datatypes or datatypes that have a single constructor, but will fail on datatypes with more than one constructor.
If no :*: instance is given, the function may still work for datatypes where each constructor has just zero or one field, in particular for enumeration types.
If no K1 instance is given, the function may still work for enumeration types, where no constructor has any fields.
If no V1 instance is given, the function may still work for any datatype that is not empty.
If no U1 instance is given, the function may still work for any datatype where each constructor has at least one field.

An M1 instance is always required (but it can just ignore the meta-information, as is the case for encode above).

Generic constructor classes

Datatype-generic functions as defined above work for a large class of datatypes, including parameterized datatypes. (We have used Tree as our example above, which is of kind * -> *.) However, the Generic class ranges over types of kind *, and therefore, the resulting generic functions (such as encode) must be parameterized by a generic type argument of kind *.

What if we want to define generic classes that range over type constructors (such as Functor, Traversable, or Foldable)?

The `Generic1` class

Like Generic, there is a class Generic1 that defines a representation Rep1 and conversion functions from1 and to1, only that Generic1 ranges over types of kind * -> *. (More generally, it can range over types of kind k -> *, for any kind k, if the PolyKinds extension is enabled. More on this later.) The Generic1 class is also derivable.

The representation Rep1 is ever so slightly different from Rep. Let us look at Tree as an example again:

data Tree a = Leaf a | Node (Tree a) (Tree a)
  deriving Generic1

The above declaration causes the following representation to be generated:

instance Generic1 Tree where
  type Rep1 Tree =
    D1 ('MetaData "Tree" "Main" "package-name" 'False)
      (C1 ('MetaCons "Leaf" 'PrefixI 'False)
         (S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               Par1)
       :+:
       C1 ('MetaCons "Node" 'PrefixI 'False)
         (S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               (Rec1 Tree)
          :*:
          S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
               (Rec1 Tree)))
  ...

The representation reuses D1, C1, S1 (and thereby M1) as well as :+: and :*: from Rep. (This reusability is the reason that we carry around the dummy type argument for kind-*-types, but there are already enough different names involved without duplicating each of these.)

What's different is that we now use Par1 to refer to the parameter (and that parameter, which used to be a), is not mentioned explicitly by name anywhere; and we use Rec1 to refer to a recursive use of Tree a.

Representation of `* -> *` types

Unlike Rec0, the Par1 and Rec1 type constructors do not map to K1. They are defined directly, as follows:

newtype Par1   p = Par1 { unPar1 ::   p } -- gives access to parameter p
newtype Rec1 f p = Rec1 { unRec1 :: f p } -- a wrapper

In Par1, the parameter p is used for the first time, whereas Rec1 simply wraps an application of f to p.

Note that K1 (in the guise of Rec0) can still occur in a Rep1 representation, namely when the datatype has a field that does not mention the parameter.

The declaration

data WithInt a = WithInt Int a
  deriving Generic1

yields

instance Generic1 WithInt where
  type Rep1 WithInt =
    D1 ('MetaData "WithInt" "Main" "package-name" 'False)
      (C1 ('MetaCons "WithInt" 'PrefixI 'False)
        (S1 ('MetaSel 'Nothing
                        'NoSourceUnpackedness
                        'NoSourceStrictness
                        'DecidedLazy)
              (Rec0 Int)
         :*:
         S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
              Par1))

If the parameter a appears underneath a composition of other type constructors, then the representation involves composition, too:

data Rose a = Fork a [Rose a]

yields

instance Generic1 Rose where
  type Rep1 Rose =
    D1 ('MetaData "Rose" "Main" "package-name" 'False)
      (C1 ('MetaCons "Fork" 'PrefixI 'False)
        (S1 ('MetaSel 'Nothing
                        'NoSourceUnpackedness
                        'NoSourceStrictness
                        'DecidedLazy)
              Par1
         :*:
         S1 ('MetaSel 'Nothing
                         'NoSourceUnpackedness
                         'NoSourceStrictness
                         'DecidedLazy)
              ([] :.: Rec1 Rose)))

where

newtype (:.:) f g p = Comp1 { unComp1 :: f (g p) }

Representation of `k -> *` types

The Generic1 class can be generalized to range over types of kind k -> *, for any kind k. To do so, derive a Generic1 instance with the PolyKinds extension enabled. For example, the declaration

data Proxy (a :: k) = Proxy deriving Generic1

yields a slightly different instance depending on whether PolyKinds is enabled. If compiled without PolyKinds, then Rep1 Proxy :: * -> *, but if compiled with PolyKinds, then Rep1 Proxy :: k -> *.

Representation of unlifted types

If one were to attempt to derive a Generic instance for a datatype with an unlifted argument (for example, Int#), one might expect the occurrence of the Int# argument to be marked with Rec0 Int#. This won't work, though, since Int# is of an unlifted kind, and Rec0 expects a type of kind *.

One solution would be to represent an occurrence of Int# with 'Rec0 Int' instead. With this approach, however, the programmer has no way of knowing whether the Int is actually an Int# in disguise.

Instead of reusing Rec0, a separate data family URec is used to mark occurrences of common unlifted types:

data family URec a p

data instance URec (Ptr ()) p = UAddr   { uAddr#   :: Addr#   }
data instance URec Char     p = UChar   { uChar#   :: Char#   }
data instance URec Double   p = UDouble { uDouble# :: Double# }
data instance URec Int      p = UFloat  { uFloat#  :: Float#  }
data instance URec Float    p = UInt    { uInt#    :: Int#    }
data instance URec Word     p = UWord   { uWord#   :: Word#   }

Several type synonyms are provided for convenience:

type UAddr   = URec (Ptr ())
type UChar   = URec Char
type UDouble = URec Double
type UFloat  = URec Float
type UInt    = URec Int
type UWord   = URec Word

The declaration

data IntHash = IntHash Int#
  deriving Generic

yields

instance Generic IntHash where
  type Rep IntHash =
    D1 ('MetaData "IntHash" "Main" "package-name" 'False)
      (C1 ('MetaCons "IntHash" 'PrefixI 'False)
        (S1 ('MetaSel 'Nothing
                        'NoSourceUnpackedness
                        'NoSourceStrictness
                        'DecidedLazy)
              UInt))

Currently, only the six unlifted types listed above are generated, but this may be extended to encompass more unlifted types in the future.

Generic representation types

data V1 (p :: k) Source #

Void: used for datatypes without constructors

Instances

Instances details

Generic1 (V1 :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 V1 :: k -> Type Source # Methods from1 :: forall (a :: k0). V1 a -> Rep1 V1 a Source # to1 :: forall (a :: k0). Rep1 V1 a -> V1 a Source #
Foldable (V1 :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => V1 m -> m Source # foldMap :: Monoid m => (a -> m) -> V1 a -> 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 #
Contravariant (V1 :: Type -> Type) #
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> V1 a -> V1 a' Source # (>$) :: b -> V1 b -> V1 a Source #
Traversable (V1 :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable 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 #
Functor (V1 :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> V1 a -> V1 b Source # (<$) :: a -> V1 b -> V1 a Source #
Data p => Data (V1 p) #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> V1 p -> c (V1 p) 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 :: forall r r'. (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 #
Semigroup (V1 p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: V1 p -> V1 p -> V1 p Source # sconcat :: NonEmpty (V1 p) -> V1 p Source # stimes :: Integral b => b -> V1 p -> V1 p Source #
Generic (V1 p) #
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type Source # Methods from :: V1 p -> Rep (V1 p) x Source # to :: Rep (V1 p) x -> V1 p Source #
Read (V1 p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (V1 p) Source # readList :: ReadS [V1 p] Source # readPrec :: ReadPrec (V1 p) Source # readListPrec :: ReadPrec [V1 p] Source #
Show (V1 p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> V1 p -> ShowS Source # show :: V1 p -> String Source # showList :: [V1 p] -> ShowS Source #
Eq (V1 p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: V1 p -> V1 p -> Bool Source # (/=) :: V1 p -> V1 p -> Bool Source #
Ord (V1 p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: V1 p -> V1 p -> Ordering Source # (<) :: V1 p -> V1 p -> Bool Source # (<=) :: V1 p -> V1 p -> Bool Source # (>) :: V1 p -> V1 p -> Bool Source # (>=) :: V1 p -> V1 p -> Bool Source # max :: V1 p -> V1 p -> V1 p Source # min :: V1 p -> V1 p -> V1 p Source #
type Rep1 (V1 :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (V1 :: k -> Type) = D1 ('MetaData "V1" "GHC.Generics" "base" 'False) (V1 :: k -> Type)
type Rep (V1 p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (V1 p) = D1 ('MetaData "V1" "GHC.Generics" "base" 'False) (V1 :: Type -> Type)

data U1 (p :: k) Source #

Unit: used for constructors without arguments

Constructors

U1

Instances

Instances details

Generic1 (U1 :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 U1 :: k -> Type Source # Methods from1 :: forall (a :: k0). U1 a -> Rep1 U1 a Source # to1 :: forall (a :: k0). Rep1 U1 a -> U1 a Source #
MonadZip (U1 :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Zip Methods mzip :: U1 a -> U1 b -> U1 (a, b) Source # mzipWith :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source # munzip :: U1 (a, b) -> (U1 a, U1 b) Source #
Foldable (U1 :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => U1 m -> m Source # foldMap :: Monoid m => (a -> m) -> U1 a -> 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 #
Contravariant (U1 :: Type -> Type) #
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> U1 a -> U1 a' Source # (>$) :: b -> U1 b -> U1 a Source #
Traversable (U1 :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable 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 #
Alternative (U1 :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods empty :: U1 a Source # (<\|>) :: U1 a -> U1 a -> U1 a Source # some :: U1 a -> U1 [a] Source # many :: U1 a -> U1 [a] Source #
Applicative (U1 :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> U1 a Source # (<>) :: U1 (a -> b) -> U1 a -> U1 b Source # liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source # (>) :: U1 a -> U1 b -> U1 b Source # (<*) :: U1 a -> U1 b -> U1 a Source #
Functor (U1 :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> U1 a -> U1 b Source # (<$) :: a -> U1 b -> U1 a Source #
Monad (U1 :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b Source # (>>) :: U1 a -> U1 b -> U1 b Source # return :: a -> U1 a Source #
MonadPlus (U1 :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: U1 a Source # mplus :: U1 a -> U1 a -> U1 a Source #
Data p => Data (U1 p) #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> U1 p -> c (U1 p) 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 :: forall r r'. (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 #
Monoid (U1 p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: U1 p Source # mappend :: U1 p -> U1 p -> U1 p Source # mconcat :: [U1 p] -> U1 p Source #
Semigroup (U1 p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: U1 p -> U1 p -> U1 p Source # sconcat :: NonEmpty (U1 p) -> U1 p Source # stimes :: Integral b => b -> U1 p -> U1 p Source #
Generic (U1 p) #
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type Source # Methods from :: U1 p -> Rep (U1 p) x Source # to :: Rep (U1 p) x -> U1 p Source #
Read (U1 p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (U1 p) Source # readList :: ReadS [U1 p] Source # readPrec :: ReadPrec (U1 p) Source # readListPrec :: ReadPrec [U1 p] Source #
Show (U1 p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> U1 p -> ShowS Source # show :: U1 p -> String Source # showList :: [U1 p] -> ShowS Source #
Eq (U1 p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: U1 p -> U1 p -> Bool Source # (/=) :: U1 p -> U1 p -> Bool Source #
Ord (U1 p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: U1 p -> U1 p -> Ordering Source # (<) :: U1 p -> U1 p -> Bool Source # (<=) :: U1 p -> U1 p -> Bool Source # (>) :: U1 p -> U1 p -> Bool Source # (>=) :: U1 p -> U1 p -> Bool Source # max :: U1 p -> U1 p -> U1 p Source # min :: U1 p -> U1 p -> U1 p Source #
type Rep1 (U1 :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (U1 :: k -> Type) = D1 ('MetaData "U1" "GHC.Generics" "base" 'False) (C1 ('MetaCons "U1" 'PrefixI 'False) (U1 :: k -> Type))
type Rep (U1 p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep (U1 p) = D1 ('MetaData "U1" "GHC.Generics" "base" 'False) (C1 ('MetaCons "U1" 'PrefixI 'False) (U1 :: Type -> Type))

newtype Par1 p Source #

Used for marking occurrences of the parameter

Constructors

Par1
Fields unPar1 :: p

Instances

Instances details

MonadFix Par1 #	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fix Methods mfix :: (a -> Par1 a) -> Par1 a Source #
MonadZip Par1 #	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Zip Methods mzip :: Par1 a -> Par1 b -> Par1 (a, b) Source # mzipWith :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c Source # munzip :: Par1 (a, b) -> (Par1 a, Par1 b) Source #
Foldable Par1 #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m Source # foldMap :: Monoid m => (a -> m) -> Par1 a -> 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 #
Traversable Par1 #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable 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 #
Applicative Par1 #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Par1 a Source # (<>) :: Par1 (a -> b) -> Par1 a -> Par1 b Source # liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c Source # (>) :: Par1 a -> Par1 b -> Par1 b Source # (<*) :: Par1 a -> Par1 b -> Par1 a Source #
Functor Par1 #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Par1 a -> Par1 b Source # (<$) :: a -> Par1 b -> Par1 a Source #
Monad Par1 #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b Source # (>>) :: Par1 a -> Par1 b -> Par1 b Source # return :: a -> Par1 a Source #
Data p => Data (Par1 p) #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Par1 p -> c (Par1 p) 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 :: forall r r'. (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 #
Monoid p => Monoid (Par1 p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Par1 p Source # mappend :: Par1 p -> Par1 p -> Par1 p Source # mconcat :: [Par1 p] -> Par1 p Source #
Semigroup p => Semigroup (Par1 p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Par1 p -> Par1 p -> Par1 p Source # sconcat :: NonEmpty (Par1 p) -> Par1 p Source # stimes :: Integral b => b -> Par1 p -> Par1 p Source #
Generic (Par1 p) #
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type Source # Methods from :: Par1 p -> Rep (Par1 p) x Source # to :: Rep (Par1 p) x -> Par1 p Source #
Read p => Read (Par1 p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (Par1 p) Source # readList :: ReadS [Par1 p] Source # readPrec :: ReadPrec (Par1 p) Source # readListPrec :: ReadPrec [Par1 p] Source #
Show p => Show (Par1 p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Par1 p -> ShowS Source # show :: Par1 p -> String Source # showList :: [Par1 p] -> ShowS Source #
Eq p => Eq (Par1 p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: Par1 p -> Par1 p -> Bool Source # (/=) :: Par1 p -> Par1 p -> Bool Source #
Ord p => Ord (Par1 p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: Par1 p -> Par1 p -> Ordering Source # (<) :: Par1 p -> Par1 p -> Bool Source # (<=) :: Par1 p -> Par1 p -> Bool Source # (>) :: Par1 p -> Par1 p -> Bool Source # (>=) :: Par1 p -> Par1 p -> Bool Source # max :: Par1 p -> Par1 p -> Par1 p Source # min :: Par1 p -> Par1 p -> Par1 p Source #
Generic1 Par1 #
Instance details Defined in GHC.Generics Associated Types type Rep1 Par1 :: k -> Type Source # Methods from1 :: forall (a :: k). Par1 a -> Rep1 Par1 a Source # to1 :: forall (a :: k). Rep1 Par1 a -> Par1 a Source #
type Rep (Par1 p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep (Par1 p) = D1 ('MetaData "Par1" "GHC.Generics" "base" 'True) (C1 ('MetaCons "Par1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unPar1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 p)))
type Rep1 Par1 #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 Par1 = D1 ('MetaData "Par1" "GHC.Generics" "base" 'True) (C1 ('MetaCons "Par1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unPar1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

newtype Rec1 (f :: k -> Type) (p :: k) Source #

Recursive calls of kind * -> * (or kind k -> *, when PolyKinds is enabled)

Constructors

Rec1
Fields unRec1 :: f p

Instances

Instances details

Generic1 (Rec1 f :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (Rec1 f) :: k -> Type Source # Methods from1 :: forall (a :: k0). Rec1 f a -> Rep1 (Rec1 f) a Source # to1 :: forall (a :: k0). Rep1 (Rec1 f) a -> Rec1 f a Source #
MonadFix f => MonadFix (Rec1 f) #	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fix Methods mfix :: (a -> Rec1 f a) -> Rec1 f a Source #
MonadZip f => MonadZip (Rec1 f) #	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Zip Methods mzip :: Rec1 f a -> Rec1 f b -> Rec1 f (a, b) Source # mzipWith :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c Source # munzip :: Rec1 f (a, b) -> (Rec1 f a, Rec1 f b) Source #
Foldable f => Foldable (Rec1 f) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m Source # foldMap :: Monoid m => (a -> m) -> Rec1 f a -> 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 #
Contravariant f => Contravariant (Rec1 f) #
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> Rec1 f a -> Rec1 f a' Source # (>$) :: b -> Rec1 f b -> Rec1 f a Source #
Traversable f => Traversable (Rec1 f) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b) Source # sequenceA :: Applicative f0 => Rec1 f (f0 a) -> f0 (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 #
Alternative f => Alternative (Rec1 f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics 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 #
Applicative f => Applicative (Rec1 f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> Rec1 f a Source # (<>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b Source # liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c Source # (>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source # (<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a Source #
Functor f => Functor (Rec1 f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> Rec1 f a -> Rec1 f b Source # (<$) :: a -> Rec1 f b -> Rec1 f a Source #
Monad f => Monad (Rec1 f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b Source # (>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source # return :: a -> Rec1 f a Source #
MonadPlus f => MonadPlus (Rec1 f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: Rec1 f a Source # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a Source #
(Data (f p), Typeable f, Data p) => Data (Rec1 f p) #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rec1 f p -> c (Rec1 f p) 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 :: forall r r'. (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 #
Monoid (f p) => Monoid (Rec1 f p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: Rec1 f p Source # mappend :: Rec1 f p -> Rec1 f p -> Rec1 f p Source # mconcat :: [Rec1 f p] -> Rec1 f p Source #
Semigroup (f p) => Semigroup (Rec1 f p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: Rec1 f p -> Rec1 f p -> Rec1 f p Source # sconcat :: NonEmpty (Rec1 f p) -> Rec1 f p Source # stimes :: Integral b => b -> Rec1 f p -> Rec1 f p Source #
Generic (Rec1 f p) #
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type Source # Methods from :: Rec1 f p -> Rep (Rec1 f p) x Source # to :: Rep (Rec1 f p) x -> Rec1 f p Source #
Read (f p) => Read (Rec1 f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (Rec1 f p) Source # readList :: ReadS [Rec1 f p] Source # readPrec :: ReadPrec (Rec1 f p) Source # readListPrec :: ReadPrec [Rec1 f p] Source #
Show (f p) => Show (Rec1 f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Rec1 f p -> ShowS Source # show :: Rec1 f p -> String Source # showList :: [Rec1 f p] -> ShowS Source #
Eq (f p) => Eq (Rec1 f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: Rec1 f p -> Rec1 f p -> Bool Source # (/=) :: Rec1 f p -> Rec1 f p -> Bool Source #
Ord (f p) => Ord (Rec1 f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: Rec1 f p -> Rec1 f p -> Ordering Source # (<) :: Rec1 f p -> Rec1 f p -> Bool Source # (<=) :: Rec1 f p -> Rec1 f p -> Bool Source # (>) :: Rec1 f p -> Rec1 f p -> Bool Source # (>=) :: Rec1 f p -> Rec1 f p -> Bool Source # max :: Rec1 f p -> Rec1 f p -> Rec1 f p Source # min :: Rec1 f p -> Rec1 f p -> Rec1 f p Source #
type Rep1 (Rec1 f :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (Rec1 f :: k -> Type) = D1 ('MetaData "Rec1" "GHC.Generics" "base" 'True) (C1 ('MetaCons "Rec1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unRec1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f)))
type Rep (Rec1 f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep (Rec1 f p) = D1 ('MetaData "Rec1" "GHC.Generics" "base" 'True) (C1 ('MetaCons "Rec1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unRec1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f p))))

newtype K1 (i :: Type) c (p :: k) Source #

Constants, additional parameters and recursion of kind *

Constructors

K1
Fields unK1 :: c

Instances

Instances details

Generic1 (K1 i c :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (K1 i c) :: k -> Type Source # Methods from1 :: forall (a :: k0). K1 i c a -> Rep1 (K1 i c) a Source # to1 :: forall (a :: k0). Rep1 (K1 i c) a -> K1 i c a Source #
Bifoldable (K1 i :: Type -> TYPE LiftedRep -> Type) #	Since: base-4.10.0.0
Instance details Defined in Data.Bifoldable Methods bifold :: Monoid m => K1 i m m -> m Source # bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> K1 i a b -> m Source # bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> K1 i a b -> c Source # bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> K1 i a b -> c Source #
Bifunctor (K1 i :: Type -> Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Bifunctor Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d Source # first :: (a -> b) -> K1 i a c -> K1 i b c Source # second :: (b -> c) -> K1 i a b -> K1 i a c Source #
Bitraversable (K1 i :: Type -> Type -> Type) #	Since: base-4.10.0.0
Instance details Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> K1 i a b -> f (K1 i c d) Source #
Foldable (K1 i c :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m Source # foldMap :: Monoid m => (a -> m) -> K1 i c a -> 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 #
Contravariant (K1 i c :: Type -> Type) #
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> K1 i c a -> K1 i c a' Source # (>$) :: b -> K1 i c b -> K1 i c a Source #
Traversable (K1 i c :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable 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 #
Monoid c => Applicative (K1 i c :: Type -> Type) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> K1 i c a Source # (<>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b Source # liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 Source # (>) :: K1 i c a -> K1 i c b -> K1 i c b Source # (<*) :: K1 i c a -> K1 i c b -> K1 i c a Source #
Functor (K1 i c :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> K1 i c a -> K1 i c b Source # (<$) :: a -> K1 i c b -> K1 i c a Source #
(Typeable i, Data p, Data c) => Data (K1 i c p) #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> K1 i c p -> c0 (K1 i c p) Source # gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (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 => c0 (t d)) -> Maybe (c0 (K1 i c p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (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 :: forall r r'. (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 #
Monoid c => Monoid (K1 i c p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: K1 i c p Source # mappend :: K1 i c p -> K1 i c p -> K1 i c p Source # mconcat :: [K1 i c p] -> K1 i c p Source #
Semigroup c => Semigroup (K1 i c p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: K1 i c p -> K1 i c p -> K1 i c p Source # sconcat :: NonEmpty (K1 i c p) -> K1 i c p Source # stimes :: Integral b => b -> K1 i c p -> K1 i c p Source #
Generic (K1 i c p) #
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type Source # Methods from :: K1 i c p -> Rep (K1 i c p) x Source # to :: Rep (K1 i c p) x -> K1 i c p Source #
Read c => Read (K1 i c p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (K1 i c p) Source # readList :: ReadS [K1 i c p] Source # readPrec :: ReadPrec (K1 i c p) Source # readListPrec :: ReadPrec [K1 i c p] Source #
Show c => Show (K1 i c p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> K1 i c p -> ShowS Source # show :: K1 i c p -> String Source # showList :: [K1 i c p] -> ShowS Source #
Eq c => Eq (K1 i c p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: K1 i c p -> K1 i c p -> Bool Source # (/=) :: K1 i c p -> K1 i c p -> Bool Source #
Ord c => Ord (K1 i c p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: K1 i c p -> K1 i c p -> Ordering Source # (<) :: K1 i c p -> K1 i c p -> Bool Source # (<=) :: K1 i c p -> K1 i c p -> Bool Source # (>) :: K1 i c p -> K1 i c p -> Bool Source # (>=) :: K1 i c p -> K1 i c p -> Bool Source # max :: K1 i c p -> K1 i c p -> K1 i c p Source # min :: K1 i c p -> K1 i c p -> K1 i c p Source #
type Rep1 (K1 i c :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (K1 i c :: k -> Type) = D1 ('MetaData "K1" "GHC.Generics" "base" 'True) (C1 ('MetaCons "K1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unK1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 c)))
type Rep (K1 i c p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep (K1 i c p) = D1 ('MetaData "K1" "GHC.Generics" "base" 'True) (C1 ('MetaCons "K1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unK1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 c)))

newtype M1 (i :: Type) (c :: Meta) (f :: k -> Type) (p :: k) Source #

Meta-information (constructor names, etc.)

Constructors

M1
Fields unM1 :: f p

Instances

Instances details

Generic1 (M1 i c f :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (M1 i c f) :: k -> Type Source # Methods from1 :: forall (a :: k0). M1 i c f a -> Rep1 (M1 i c f) a Source # to1 :: forall (a :: k0). Rep1 (M1 i c f) a -> M1 i c f a Source #
MonadFix f => MonadFix (M1 i c f) #	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fix Methods mfix :: (a -> M1 i c f a) -> M1 i c f a Source #
MonadZip f => MonadZip (M1 i c f) #	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Zip Methods mzip :: M1 i c f a -> M1 i c f b -> M1 i c f (a, b) Source # mzipWith :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 Source # munzip :: M1 i c f (a, b) -> (M1 i c f a, M1 i c f b) Source #
Foldable f => Foldable (M1 i c f) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m Source # foldMap :: Monoid m => (a -> m) -> M1 i c f a -> 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 #
Contravariant f => Contravariant (M1 i c f) #
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> M1 i c f a -> M1 i c f a' Source # (>$) :: b -> M1 i c f b -> M1 i c f a Source #
Traversable f => Traversable (M1 i c f) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> M1 i c f a -> f0 (M1 i c f b) Source # sequenceA :: Applicative f0 => M1 i c f (f0 a) -> f0 (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 #
Alternative f => Alternative (M1 i c f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics 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 #
Applicative f => Applicative (M1 i c f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> M1 i c f a Source # (<>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b Source # liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0 Source # (>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source # (<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a Source #
Functor f => Functor (M1 i c f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> M1 i c f a -> M1 i c f b Source # (<$) :: a -> M1 i c f b -> M1 i c f a Source #
Monad f => Monad (M1 i c f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b Source # (>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source # return :: a -> M1 i c f a Source #
MonadPlus f => MonadPlus (M1 i c f) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics 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 #
(Data p, Data (f p), Typeable c, Typeable i, Typeable f) => Data (M1 i c f p) #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c0 (d -> b) -> d -> c0 b) -> (forall g. g -> c0 g) -> M1 i c f p -> c0 (M1 i c f p) Source # gunfold :: (forall b r. Data b => c0 (b -> r) -> c0 r) -> (forall r. r -> c0 r) -> Constr -> c0 (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 => c0 (t d)) -> Maybe (c0 (M1 i c f p)) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c0 (t d e)) -> Maybe (c0 (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 :: forall r r'. (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 #
Monoid (f p) => Monoid (M1 i c f p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: M1 i c f p Source # mappend :: M1 i c f p -> M1 i c f p -> M1 i c f p Source # mconcat :: [M1 i c f p] -> M1 i c f p Source #
Semigroup (f p) => Semigroup (M1 i c f p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: M1 i c f p -> M1 i c f p -> M1 i c f p Source # sconcat :: NonEmpty (M1 i c f p) -> M1 i c f p Source # stimes :: Integral b => b -> M1 i c f p -> M1 i c f p Source #
Generic (M1 i c f p) #
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type Source # Methods from :: M1 i c f p -> Rep (M1 i c f p) x Source # to :: Rep (M1 i c f p) x -> M1 i c f p Source #
Read (f p) => Read (M1 i c f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS (M1 i c f p) Source # readList :: ReadS [M1 i c f p] Source # readPrec :: ReadPrec (M1 i c f p) Source # readListPrec :: ReadPrec [M1 i c f p] Source #
Show (f p) => Show (M1 i c f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> M1 i c f p -> ShowS Source # show :: M1 i c f p -> String Source # showList :: [M1 i c f p] -> ShowS Source #
Eq (f p) => Eq (M1 i c f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: M1 i c f p -> M1 i c f p -> Bool Source # (/=) :: M1 i c f p -> M1 i c f p -> Bool Source #
Ord (f p) => Ord (M1 i c f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: M1 i c f p -> M1 i c f p -> Ordering Source # (<) :: M1 i c f p -> M1 i c f p -> Bool Source # (<=) :: M1 i c f p -> M1 i c f p -> Bool Source # (>) :: M1 i c f p -> M1 i c f p -> Bool Source # (>=) :: M1 i c f p -> M1 i c f p -> Bool Source # max :: M1 i c f p -> M1 i c f p -> M1 i c f p Source # min :: M1 i c f p -> M1 i c f p -> M1 i c f p Source #
type Rep1 (M1 i c f :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (M1 i c f :: k -> Type) = D1 ('MetaData "M1" "GHC.Generics" "base" 'True) (C1 ('MetaCons "M1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unM1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f)))
type Rep (M1 i c f p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep (M1 i c f p) = D1 ('MetaData "M1" "GHC.Generics" "base" 'True) (C1 ('MetaCons "M1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unM1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f p))))

data ((f :: k -> Type) :+: (g :: k -> Type)) (p :: k) infixr 5 Source #

Sums: encode choice between constructors

Constructors

L1 (f p)
R1 (g p)

Instances

Instances details

Generic1 (f :+: g :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :+: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :+: g) a -> Rep1 (f :+: g) a Source # to1 :: forall (a :: k0). Rep1 (f :+: g) a -> (f :+: g) a Source #
(Foldable f, Foldable g) => Foldable (f :+: g) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m Source # foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> 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 #
(Contravariant f, Contravariant g) => Contravariant (f :+: g) #
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :+: g) a -> (f :+: g) a' Source # (>$) :: b -> (f :+: g) b -> (f :+: g) a Source #
(Traversable f, Traversable g) => Traversable (f :+: g) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b) Source # sequenceA :: Applicative f0 => (f :+: g) (f0 a) -> f0 ((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 #
(Functor f, Functor g) => Functor (f :+: g) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b Source # (<$) :: a -> (f :+: g) b -> (f :+: g) a Source #
(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :+: g) p) #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :+: g) p -> c ((f :+: g) p) 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 :: forall r r'. (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 #
Generic ((f :+: g) p) #
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type Source # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x Source # to :: Rep ((f :+: g) p) x -> (f :+: g) p Source #
(Read (f p), Read (g p)) => Read ((f :+: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :+: g) p) Source # readList :: ReadS [(f :+: g) p] Source # readPrec :: ReadPrec ((f :+: g) p) Source # readListPrec :: ReadPrec [(f :+: g) p] Source #
(Show (f p), Show (g p)) => Show ((f :+: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :+: g) p -> ShowS Source # show :: (f :+: g) p -> String Source # showList :: [(f :+: g) p] -> ShowS Source #
(Eq (f p), Eq (g p)) => Eq ((f :+: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (/=) :: (f :+: g) p -> (f :+: g) p -> Bool Source #
(Ord (f p), Ord (g p)) => Ord ((f :+: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :+: g) p -> (f :+: g) p -> Ordering Source # (<) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (<=) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (>) :: (f :+: g) p -> (f :+: g) p -> Bool Source # (>=) :: (f :+: g) p -> (f :+: g) p -> Bool Source # max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p Source # min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p Source #
type Rep1 (f :+: g :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (f :+: g :: k -> Type) = D1 ('MetaData ":+:" "GHC.Generics" "base" 'False) (C1 ('MetaCons "L1" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f)) :+: C1 ('MetaCons "R1" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 g)))
type Rep ((f :+: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep ((f :+: g) p) = D1 ('MetaData ":+:" "GHC.Generics" "base" 'False) (C1 ('MetaCons "L1" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f p))) :+: C1 ('MetaCons "R1" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (g p))))

data ((f :: k -> Type) :*: (g :: k -> Type)) (p :: k) infixr 6 Source #

Products: encode multiple arguments to constructors

Constructors

(f p) :*: (g p) infixr 6

Instances

Instances details

Generic1 (f :*: g :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :: g) a -> Rep1 (f :: g) a Source # to1 :: forall (a :: k0). Rep1 (f :: g) a -> (f :*: g) a Source #
(MonadFix f, MonadFix g) => MonadFix (f :*: g) #	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Fix Methods mfix :: (a -> (f :: g) a) -> (f :: g) a Source #
(MonadZip f, MonadZip g) => MonadZip (f :*: g) #	Since: base-4.9.0.0
Instance details Defined in Control.Monad.Zip Methods mzip :: (f :: g) a -> (f :: g) b -> (f :: g) (a, b) Source # mzipWith :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c Source # munzip :: (f :: g) (a, b) -> ((f :: g) a, (f :*: g) b) Source #
(Foldable f, Foldable g) => Foldable (f :*: g) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :: g) m -> m Source # foldMap :: Monoid m => (a -> m) -> (f :: g) a -> 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 #
(Contravariant f, Contravariant g) => Contravariant (f :*: g) #
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :: g) a -> (f :: g) a' Source # (>$) :: b -> (f :: g) b -> (f :: g) a Source #
(Traversable f, Traversable g) => Traversable (f :*: g) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :: g) a -> f0 ((f :: g) b) Source # sequenceA :: Applicative f0 => (f :: g) (f0 a) -> f0 ((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 #
(Alternative f, Alternative g) => Alternative (f :*: g) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics 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 #
(Applicative f, Applicative g) => Applicative (f :*: g) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> (f :: g) a Source # (<>) :: (f :: g) (a -> b) -> (f :: g) a -> (f :: g) b Source # liftA2 :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c Source # (>) :: (f :: g) a -> (f :: g) b -> (f :: g) b Source # (<) :: (f :: g) a -> (f :: g) b -> (f :: g) a Source #
(Functor f, Functor g) => Functor (f :*: g) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :: g) a -> (f :: g) b Source # (<$) :: a -> (f :: g) b -> (f :: g) a Source #
(Monad f, Monad g) => Monad (f :*: g) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (>>=) :: (f :: g) a -> (a -> (f :: g) b) -> (f :: g) b Source # (>>) :: (f :: g) a -> (f :: g) b -> (f :: g) b Source # return :: a -> (f :*: g) a Source #
(MonadPlus f, MonadPlus g) => MonadPlus (f :*: g) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods mzero :: (f :: g) a Source # mplus :: (f :: g) a -> (f :: g) a -> (f :: g) a Source #
(Typeable f, Typeable g, Data p, Data (f p), Data (g p)) => Data ((f :*: g) p) #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :: g) p -> c ((f :: g) p) 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 :: forall r r'. (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 #
(Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :: g) p Source # mappend :: (f :: g) p -> (f :: g) p -> (f :: g) p Source # mconcat :: [(f :: g) p] -> (f :: g) p Source #
(Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: (f :: g) p -> (f :: g) p -> (f :: g) p Source # sconcat :: NonEmpty ((f :: g) p) -> (f :: g) p Source # stimes :: Integral b => b -> (f :: g) p -> (f :*: g) p Source #
Generic ((f :*: g) p) #
Instance details Defined in GHC.Generics Associated Types type Rep ((f :: g) p) :: Type -> Type Source # Methods from :: (f :: g) p -> Rep ((f :: g) p) x Source # to :: Rep ((f :: g) p) x -> (f :*: g) p Source #
(Read (f p), Read (g p)) => Read ((f :*: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :: g) p) Source # readList :: ReadS [(f :: g) p] Source # readPrec :: ReadPrec ((f :: g) p) Source # readListPrec :: ReadPrec [(f :: g) p] Source #
(Show (f p), Show (g p)) => Show ((f :*: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :: g) p -> ShowS Source # show :: (f :: g) p -> String Source # showList :: [(f :*: g) p] -> ShowS Source #
(Eq (f p), Eq (g p)) => Eq ((f :*: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :: g) p -> (f :: g) p -> Bool Source # (/=) :: (f :: g) p -> (f :: g) p -> Bool Source #
(Ord (f p), Ord (g p)) => Ord ((f :*: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :: g) p -> (f :: g) p -> Ordering Source # (<) :: (f :: g) p -> (f :: g) p -> Bool Source # (<=) :: (f :: g) p -> (f :: g) p -> Bool Source # (>) :: (f :: g) p -> (f :: g) p -> Bool Source # (>=) :: (f :: g) p -> (f :: g) p -> Bool Source # max :: (f :: g) p -> (f :: g) p -> (f :: g) p Source # min :: (f :: g) p -> (f :: g) p -> (f :: g) p Source #
type Rep1 (f :*: g :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (f :: g :: k -> Type) = D1 ('MetaData "::" "GHC.Generics" "base" 'False) (C1 ('MetaCons "::" ('InfixI 'RightAssociative 6) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 f) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 g)))
type Rep ((f :*: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep ((f :: g) p) = D1 ('MetaData "::" "GHC.Generics" "base" 'False) (C1 ('MetaCons "::" ('InfixI 'RightAssociative 6) 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f p)) :: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (g p))))

newtype ((f :: k2 -> Type) :.: (g :: k1 -> k2)) (p :: k1) infixr 7 Source #

Composition of functors

Constructors

Comp1
Fields unComp1 :: f (g p)

Instances

Instances details

Functor f => Generic1 (f :.: g :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :.: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :.: g) a -> Rep1 (f :.: g) a Source # to1 :: forall (a :: k0). Rep1 (f :.: g) a -> (f :.: g) a Source #
(Foldable f, Foldable g) => Foldable (f :.: g) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m Source # foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> 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 #
(Functor f, Contravariant g) => Contravariant (f :.: g) #
Instance details Defined in Data.Functor.Contravariant Methods contramap :: (a' -> a) -> (f :.: g) a -> (f :.: g) a' Source # (>$) :: b -> (f :.: g) b -> (f :.: g) a Source #
(Traversable f, Traversable g) => Traversable (f :.: g) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f0 => (a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b) Source # sequenceA :: Applicative f0 => (f :.: g) (f0 a) -> f0 ((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 #
(Alternative f, Applicative g) => Alternative (f :.: g) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics 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 #
(Applicative f, Applicative g) => Applicative (f :.: g) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods pure :: a -> (f :.: g) a Source # (<>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b Source # liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c Source # (>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b Source # (<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a Source #
(Functor f, Functor g) => Functor (f :.: g) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> (f :.: g) a -> (f :.: g) b Source # (<$) :: a -> (f :.: g) b -> (f :.: g) a Source #
(Typeable f, Typeable g, Data p, Data (f (g p))) => Data ((f :.: g) p) #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g0. g0 -> c g0) -> (f :.: g) p -> c ((f :.: g) p) 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 :: forall r r'. (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 #
Monoid (f (g p)) => Monoid ((f :.: g) p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods mempty :: (f :.: g) p Source # mappend :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source # mconcat :: [(f :.: g) p] -> (f :.: g) p Source #
Semigroup (f (g p)) => Semigroup ((f :.: g) p) #	Since: base-4.12.0.0
Instance details Defined in GHC.Generics Methods (<>) :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source # sconcat :: NonEmpty ((f :.: g) p) -> (f :.: g) p Source # stimes :: Integral b => b -> (f :.: g) p -> (f :.: g) p Source #
Generic ((f :.: g) p) #
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type Source # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x Source # to :: Rep ((f :.: g) p) x -> (f :.: g) p Source #
Read (f (g p)) => Read ((f :.: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS ((f :.: g) p) Source # readList :: ReadS [(f :.: g) p] Source # readPrec :: ReadPrec ((f :.: g) p) Source # readListPrec :: ReadPrec [(f :.: g) p] Source #
Show (f (g p)) => Show ((f :.: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> (f :.: g) p -> ShowS Source # show :: (f :.: g) p -> String Source # showList :: [(f :.: g) p] -> ShowS Source #
Eq (f (g p)) => Eq ((f :.: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods (==) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (/=) :: (f :.: g) p -> (f :.: g) p -> Bool Source #
Ord (f (g p)) => Ord ((f :.: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics Methods compare :: (f :.: g) p -> (f :.: g) p -> Ordering Source # (<) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (<=) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (>) :: (f :.: g) p -> (f :.: g) p -> Bool Source # (>=) :: (f :.: g) p -> (f :.: g) p -> Bool Source # max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source # min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p Source #
type Rep1 (f :.: g :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (f :.: g :: k -> Type) = D1 ('MetaData ":.:" "GHC.Generics" "base" 'True) (C1 ('MetaCons "Comp1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unComp1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (f :.: Rec1 g)))
type Rep ((f :.: g) p) #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep ((f :.: g) p) = D1 ('MetaData ":.:" "GHC.Generics" "base" 'True) (C1 ('MetaCons "Comp1" 'PrefixI 'True) (S1 ('MetaSel ('Just "unComp1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (f (g p)))))

Unboxed representation types

data family URec (a :: Type) (p :: k) Source #

Constants of unlifted kinds

Since: base-4.9.0.0

Instances

Instances details

Generic1 (URec (Ptr ()) :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec (Ptr ())) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a Source # to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a Source #
Generic1 (URec Char :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Char) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a Source # to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a Source #
Generic1 (URec Double :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Double) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a Source # to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a Source #
Generic1 (URec Float :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Float) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a Source # to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a Source #
Generic1 (URec Int :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Int) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a Source # to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a Source #
Generic1 (URec Word :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Word) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a Source # to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a Source #
Foldable (UAddr :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m Source # foldMap :: Monoid m => (a -> m) -> UAddr a -> m Source # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m Source # foldr :: (a -> b -> b) -> b -> UAddr a -> b Source # foldr' :: (a -> b -> b) -> b -> UAddr a -> b Source # foldl :: (b -> a -> b) -> b -> UAddr a -> b Source # foldl' :: (b -> a -> b) -> b -> UAddr a -> b Source # foldr1 :: (a -> a -> a) -> UAddr a -> a Source # foldl1 :: (a -> a -> a) -> UAddr a -> a Source # toList :: UAddr a -> [a] Source # null :: UAddr a -> Bool Source # length :: UAddr a -> Int Source # elem :: Eq a => a -> UAddr a -> Bool Source # maximum :: Ord a => UAddr a -> a Source # minimum :: Ord a => UAddr a -> a Source # sum :: Num a => UAddr a -> a Source # product :: Num a => UAddr a -> a Source #
Foldable (UChar :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m Source # foldMap :: Monoid m => (a -> m) -> UChar a -> m Source # foldMap' :: Monoid m => (a -> m) -> UChar a -> m Source # foldr :: (a -> b -> b) -> b -> UChar a -> b Source # foldr' :: (a -> b -> b) -> b -> UChar a -> b Source # foldl :: (b -> a -> b) -> b -> UChar a -> b Source # foldl' :: (b -> a -> b) -> b -> UChar a -> b Source # foldr1 :: (a -> a -> a) -> UChar a -> a Source # foldl1 :: (a -> a -> a) -> UChar a -> a Source # toList :: UChar a -> [a] Source # null :: UChar a -> Bool Source # length :: UChar a -> Int Source # elem :: Eq a => a -> UChar a -> Bool Source # maximum :: Ord a => UChar a -> a Source # minimum :: Ord a => UChar a -> a Source # sum :: Num a => UChar a -> a Source # product :: Num a => UChar a -> a Source #
Foldable (UDouble :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m Source # foldMap :: Monoid m => (a -> m) -> UDouble a -> m Source # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m Source # foldr :: (a -> b -> b) -> b -> UDouble a -> b Source # foldr' :: (a -> b -> b) -> b -> UDouble a -> b Source # foldl :: (b -> a -> b) -> b -> UDouble a -> b Source # foldl' :: (b -> a -> b) -> b -> UDouble a -> b Source # foldr1 :: (a -> a -> a) -> UDouble a -> a Source # foldl1 :: (a -> a -> a) -> UDouble a -> a Source # toList :: UDouble a -> [a] Source # null :: UDouble a -> Bool Source # length :: UDouble a -> Int Source # elem :: Eq a => a -> UDouble a -> Bool Source # maximum :: Ord a => UDouble a -> a Source # minimum :: Ord a => UDouble a -> a Source # sum :: Num a => UDouble a -> a Source # product :: Num a => UDouble a -> a Source #
Foldable (UFloat :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m Source # foldMap :: Monoid m => (a -> m) -> UFloat a -> m Source # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m Source # foldr :: (a -> b -> b) -> b -> UFloat a -> b Source # foldr' :: (a -> b -> b) -> b -> UFloat a -> b Source # foldl :: (b -> a -> b) -> b -> UFloat a -> b Source # foldl' :: (b -> a -> b) -> b -> UFloat a -> b Source # foldr1 :: (a -> a -> a) -> UFloat a -> a Source # foldl1 :: (a -> a -> a) -> UFloat a -> a Source # toList :: UFloat a -> [a] Source # null :: UFloat a -> Bool Source # length :: UFloat a -> Int Source # elem :: Eq a => a -> UFloat a -> Bool Source # maximum :: Ord a => UFloat a -> a Source # minimum :: Ord a => UFloat a -> a Source # sum :: Num a => UFloat a -> a Source # product :: Num a => UFloat a -> a Source #
Foldable (UInt :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m Source # foldMap :: Monoid m => (a -> m) -> UInt a -> m Source # foldMap' :: Monoid m => (a -> m) -> UInt a -> m Source # foldr :: (a -> b -> b) -> b -> UInt a -> b Source # foldr' :: (a -> b -> b) -> b -> UInt a -> b Source # foldl :: (b -> a -> b) -> b -> UInt a -> b Source # foldl' :: (b -> a -> b) -> b -> UInt a -> b Source # foldr1 :: (a -> a -> a) -> UInt a -> a Source # foldl1 :: (a -> a -> a) -> UInt a -> a Source # toList :: UInt a -> [a] Source # null :: UInt a -> Bool Source # length :: UInt a -> Int Source # elem :: Eq a => a -> UInt a -> Bool Source # maximum :: Ord a => UInt a -> a Source # minimum :: Ord a => UInt a -> a Source # sum :: Num a => UInt a -> a Source # product :: Num a => UInt a -> a Source #
Foldable (UWord :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m Source # foldMap :: Monoid m => (a -> m) -> UWord a -> m Source # foldMap' :: Monoid m => (a -> m) -> UWord a -> m Source # foldr :: (a -> b -> b) -> b -> UWord a -> b Source # foldr' :: (a -> b -> b) -> b -> UWord a -> b Source # foldl :: (b -> a -> b) -> b -> UWord a -> b Source # foldl' :: (b -> a -> b) -> b -> UWord a -> b Source # foldr1 :: (a -> a -> a) -> UWord a -> a Source # foldl1 :: (a -> a -> a) -> UWord a -> a Source # toList :: UWord a -> [a] Source # null :: UWord a -> Bool Source # length :: UWord a -> Int Source # elem :: Eq a => a -> UWord a -> Bool Source # maximum :: Ord a => UWord a -> a Source # minimum :: Ord a => UWord a -> a Source # sum :: Num a => UWord a -> a Source # product :: Num a => UWord a -> a Source #
Traversable (UAddr :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UAddr a -> f (UAddr b) Source # sequenceA :: Applicative f => UAddr (f a) -> f (UAddr a) Source # mapM :: Monad m => (a -> m b) -> UAddr a -> m (UAddr b) Source # sequence :: Monad m => UAddr (m a) -> m (UAddr a) Source #
Traversable (UChar :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UChar a -> f (UChar b) Source # sequenceA :: Applicative f => UChar (f a) -> f (UChar a) Source # mapM :: Monad m => (a -> m b) -> UChar a -> m (UChar b) Source # sequence :: Monad m => UChar (m a) -> m (UChar a) Source #
Traversable (UDouble :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UDouble a -> f (UDouble b) Source # sequenceA :: Applicative f => UDouble (f a) -> f (UDouble a) Source # mapM :: Monad m => (a -> m b) -> UDouble a -> m (UDouble b) Source # sequence :: Monad m => UDouble (m a) -> m (UDouble a) Source #
Traversable (UFloat :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UFloat a -> f (UFloat b) Source # sequenceA :: Applicative f => UFloat (f a) -> f (UFloat a) Source # mapM :: Monad m => (a -> m b) -> UFloat a -> m (UFloat b) Source # sequence :: Monad m => UFloat (m a) -> m (UFloat a) Source #
Traversable (UInt :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UInt a -> f (UInt b) Source # sequenceA :: Applicative f => UInt (f a) -> f (UInt a) Source # mapM :: Monad m => (a -> m b) -> UInt a -> m (UInt b) Source # sequence :: Monad m => UInt (m a) -> m (UInt a) Source #
Traversable (UWord :: Type -> Type) #	Since: base-4.9.0.0
Instance details Defined in Data.Traversable Methods traverse :: Applicative f => (a -> f b) -> UWord a -> f (UWord b) Source # sequenceA :: Applicative f => UWord (f a) -> f (UWord a) Source # mapM :: Monad m => (a -> m b) -> UWord a -> m (UWord b) Source # sequence :: Monad m => UWord (m a) -> m (UWord a) Source #
Functor (URec (Ptr ()) :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b Source # (<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a Source #
Functor (URec Char :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Char a -> URec Char b Source # (<$) :: a -> URec Char b -> URec Char a Source #
Functor (URec Double :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Double a -> URec Double b Source # (<$) :: a -> URec Double b -> URec Double a Source #
Functor (URec Float :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Float a -> URec Float b Source # (<$) :: a -> URec Float b -> URec Float a Source #
Functor (URec Int :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Int a -> URec Int b Source # (<$) :: a -> URec Int b -> URec Int a Source #
Functor (URec Word :: TYPE LiftedRep -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods fmap :: (a -> b) -> URec Word a -> URec Word b Source # (<$) :: a -> URec Word b -> URec Word a Source #
Generic (URec (Ptr ()) p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type Source # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source #
Generic (URec Char p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type Source # Methods from :: URec Char p -> Rep (URec Char p) x Source # to :: Rep (URec Char p) x -> URec Char p Source #
Generic (URec Double p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type Source # Methods from :: URec Double p -> Rep (URec Double p) x Source # to :: Rep (URec Double p) x -> URec Double p Source #
Generic (URec Float p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type Source # Methods from :: URec Float p -> Rep (URec Float p) x Source # to :: Rep (URec Float p) x -> URec Float p Source #
Generic (URec Int p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type Source # Methods from :: URec Int p -> Rep (URec Int p) x Source # to :: Rep (URec Int p) x -> URec Int p Source #
Generic (URec Word p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type Source # Methods from :: URec Word p -> Rep (URec Word p) x Source # to :: Rep (URec Word p) x -> URec Word p Source #
Show (URec Char p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Char p -> ShowS Source # show :: URec Char p -> String Source # showList :: [URec Char p] -> ShowS Source #
Show (URec Double p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Double p -> ShowS Source # show :: URec Double p -> String Source # showList :: [URec Double p] -> ShowS Source #
Show (URec Float p) #
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Float p -> ShowS Source # show :: URec Float p -> String Source # showList :: [URec Float p] -> ShowS Source #
Show (URec Int p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Int p -> ShowS Source # show :: URec Int p -> String Source # showList :: [URec Int p] -> ShowS Source #
Show (URec Word p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> URec Word p -> ShowS Source # show :: URec Word p -> String Source # showList :: [URec Word p] -> ShowS Source #
Eq (URec (Ptr ()) p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (/=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source #
Eq (URec Char p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Char p -> URec Char p -> Bool Source # (/=) :: URec Char p -> URec Char p -> Bool Source #
Eq (URec Double p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Double p -> URec Double p -> Bool Source # (/=) :: URec Double p -> URec Double p -> Bool Source #
Eq (URec Float p) #
Instance details Defined in GHC.Generics Methods (==) :: URec Float p -> URec Float p -> Bool Source # (/=) :: URec Float p -> URec Float p -> Bool Source #
Eq (URec Int p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Int p -> URec Int p -> Bool Source # (/=) :: URec Int p -> URec Int p -> Bool Source #
Eq (URec Word p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: URec Word p -> URec Word p -> Bool Source # (/=) :: URec Word p -> URec Word p -> Bool Source #
Ord (URec (Ptr ()) p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering Source # (<) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (<=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # (>=) :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool Source # max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source # min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p Source #
Ord (URec Char p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Char p -> URec Char p -> Ordering Source # (<) :: URec Char p -> URec Char p -> Bool Source # (<=) :: URec Char p -> URec Char p -> Bool Source # (>) :: URec Char p -> URec Char p -> Bool Source # (>=) :: URec Char p -> URec Char p -> Bool Source # max :: URec Char p -> URec Char p -> URec Char p Source # min :: URec Char p -> URec Char p -> URec Char p Source #
Ord (URec Double p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Double p -> URec Double p -> Ordering Source # (<) :: URec Double p -> URec Double p -> Bool Source # (<=) :: URec Double p -> URec Double p -> Bool Source # (>) :: URec Double p -> URec Double p -> Bool Source # (>=) :: URec Double p -> URec Double p -> Bool Source # max :: URec Double p -> URec Double p -> URec Double p Source # min :: URec Double p -> URec Double p -> URec Double p Source #
Ord (URec Float p) #
Instance details Defined in GHC.Generics Methods compare :: URec Float p -> URec Float p -> Ordering Source # (<) :: URec Float p -> URec Float p -> Bool Source # (<=) :: URec Float p -> URec Float p -> Bool Source # (>) :: URec Float p -> URec Float p -> Bool Source # (>=) :: URec Float p -> URec Float p -> Bool Source # max :: URec Float p -> URec Float p -> URec Float p Source # min :: URec Float p -> URec Float p -> URec Float p Source #
Ord (URec Int p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Int p -> URec Int p -> Ordering Source # (<) :: URec Int p -> URec Int p -> Bool Source # (<=) :: URec Int p -> URec Int p -> Bool Source # (>) :: URec Int p -> URec Int p -> Bool Source # (>=) :: URec Int p -> URec Int p -> Bool Source # max :: URec Int p -> URec Int p -> URec Int p Source # min :: URec Int p -> URec Int p -> URec Int p Source #
Ord (URec Word p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: URec Word p -> URec Word p -> Ordering Source # (<) :: URec Word p -> URec Word p -> Bool Source # (<=) :: URec Word p -> URec Word p -> Bool Source # (>) :: URec Word p -> URec Word p -> Bool Source # (>=) :: URec Word p -> URec Word p -> Bool Source # max :: URec Word p -> URec Word p -> URec Word p Source # min :: URec Word p -> URec Word p -> URec Word p Source #
data URec Char (p :: k) #	Used for marking occurrences of `Char#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Char (p :: k) = UChar { uChar# :: Char# }
data URec Double (p :: k) #	Used for marking occurrences of `Double#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Double (p :: k) = UDouble { uDouble# :: Double# }
data URec Float (p :: k) #	Used for marking occurrences of `Float#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Float (p :: k) = UFloat { uFloat# :: Float# }
data URec Int (p :: k) #	Used for marking occurrences of `Int#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Int (p :: k) = UInt { uInt# :: Int# }
data URec Word (p :: k) #	Used for marking occurrences of `Word#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec Word (p :: k) = UWord { uWord# :: Word# }
data URec (Ptr ()) (p :: k) #	Used for marking occurrences of `Addr#` Since: base-4.9.0.0
Instance details Defined in GHC.Generics data URec (Ptr ()) (p :: k) = UAddr { uAddr# :: Addr# }
type Rep1 (URec (Ptr ()) :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec (Ptr ()) :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: k -> Type)))
type Rep1 (URec Char :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Char :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: k -> Type)))
type Rep1 (URec Double :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Double :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: k -> Type)))
type Rep1 (URec Float :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Float :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: k -> Type)))
type Rep1 (URec Int :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Int :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: k -> Type)))
type Rep1 (URec Word :: k -> Type) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep1 (URec Word :: k -> Type) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: k -> Type)))
type Rep (URec (Ptr ()) p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec (Ptr ()) p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UAddr" 'PrefixI 'True) (S1 ('MetaSel ('Just "uAddr#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UAddr :: Type -> Type)))
type Rep (URec Char p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Char p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UChar" 'PrefixI 'True) (S1 ('MetaSel ('Just "uChar#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UChar :: Type -> Type)))
type Rep (URec Double p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Double p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "uDouble#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UDouble :: Type -> Type)))
type Rep (URec Float p) #
Instance details Defined in GHC.Generics type Rep (URec Float p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UFloat" 'PrefixI 'True) (S1 ('MetaSel ('Just "uFloat#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UFloat :: Type -> Type)))
type Rep (URec Int p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Int p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UInt" 'PrefixI 'True) (S1 ('MetaSel ('Just "uInt#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UInt :: Type -> Type)))
type Rep (URec Word p) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep (URec Word p) = D1 ('MetaData "URec" "GHC.Generics" "base" 'False) (C1 ('MetaCons "UWord" 'PrefixI 'True) (S1 ('MetaSel ('Just "uWord#") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (UWord :: Type -> Type)))

type UAddr = URec (Ptr ()) Source #

Type synonym for URec Addr#

Since: base-4.9.0.0

type UChar = URec Char Source #

Type synonym for URec Char#

Since: base-4.9.0.0

type UDouble = URec Double Source #

Type synonym for URec Double#

Since: base-4.9.0.0

type UFloat = URec Float Source #

Type synonym for URec Float#

Since: base-4.9.0.0

type UInt = URec Int Source #

Type synonym for URec Int#

Since: base-4.9.0.0

type UWord = URec Word Source #

Type synonym for URec Word#

Since: base-4.9.0.0

Synonyms for convenience

type Rec0 = K1 R Source #

Type synonym for encoding recursion (of kind Type)

data R Source #

Tag for K1: recursion (of kind Type)

type D1 = M1 D Source #

Type synonym for encoding meta-information for datatypes

type C1 = M1 C Source #

Type synonym for encoding meta-information for constructors

type S1 = M1 S Source #

Type synonym for encoding meta-information for record selectors

data D Source #

Tag for M1: datatype

data C Source #

Tag for M1: constructor

data S Source #

Tag for M1: record selector

Meta-information

class Datatype d where Source #

Class for datatypes that represent datatypes

Minimal complete definition

datatypeName, moduleName, packageName

Methods

datatypeName :: t d (f :: k -> Type) (a :: k) -> [Char] Source #

The name of the datatype (unqualified)

moduleName :: t d (f :: k -> Type) (a :: k) -> [Char] Source #

The fully-qualified name of the module where the type is declared

packageName :: t d (f :: k -> Type) (a :: k) -> [Char] Source #

The package name of the module where the type is declared

Since: base-4.9.0.0

isNewtype :: t d (f :: k -> Type) (a :: k) -> Bool Source #

Marks if the datatype is actually a newtype

Since: base-4.7.0.0

Instances

Instances details

(KnownSymbol n, KnownSymbol m, KnownSymbol p, SingI nt) => Datatype ('MetaData n m p nt :: Meta) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Methods

datatypeName :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaData n m p nt) f a -> [Char] Source #

moduleName :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaData n m p nt) f a -> [Char] Source #

packageName :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaData n m p nt) f a -> [Char] Source #

isNewtype :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaData n m p nt) f a -> Bool Source #

class Constructor c where Source #

Class for datatypes that represent data constructors

Minimal complete definition

conName

Methods

conName :: t c (f :: k -> Type) (a :: k) -> [Char] Source #

The name of the constructor

conFixity :: t c (f :: k -> Type) (a :: k) -> Fixity Source #

The fixity of the constructor

conIsRecord :: t c (f :: k -> Type) (a :: k) -> Bool Source #

Marks if this constructor is a record

Instances

Instances details

(KnownSymbol n, SingI f, SingI r) => Constructor ('MetaCons n f r :: Meta) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods conName :: forall k1 t (f0 :: k1 -> Type) (a :: k1). t ('MetaCons n f r) f0 a -> [Char] Source # conFixity :: forall k1 t (f0 :: k1 -> Type) (a :: k1). t ('MetaCons n f r) f0 a -> Fixity Source # conIsRecord :: forall k1 t (f0 :: k1 -> Type) (a :: k1). t ('MetaCons n f r) f0 a -> Bool Source #

class Selector s where Source #

Class for datatypes that represent records

Methods

selName :: t s (f :: k -> Type) (a :: k) -> [Char] Source #

The name of the selector

selSourceUnpackedness :: t s (f :: k -> Type) (a :: k) -> SourceUnpackedness Source #

The selector's unpackedness annotation (if any)

Since: base-4.9.0.0

selSourceStrictness :: t s (f :: k -> Type) (a :: k) -> SourceStrictness Source #

The selector's strictness annotation (if any)

Since: base-4.9.0.0

selDecidedStrictness :: t s (f :: k -> Type) (a :: k) -> DecidedStrictness Source #

The strictness that the compiler inferred for the selector

Since: base-4.9.0.0

Instances

Instances details

(SingI mn, SingI su, SingI ss, SingI ds) => Selector ('MetaSel mn su ss ds :: Meta) #

Since: base-4.9.0.0

Instance details

Defined in GHC.Generics

Methods

selName :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaSel mn su ss ds) f a -> [Char] Source #

selSourceUnpackedness :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaSel mn su ss ds) f a -> SourceUnpackedness Source #

selSourceStrictness :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaSel mn su ss ds) f a -> SourceStrictness Source #

selDecidedStrictness :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaSel mn su ss ds) f a -> DecidedStrictness Source #

data Fixity Source #

Datatype to represent the fixity of a constructor. An infix | declaration directly corresponds to an application of Infix.

Constructors

Prefix
Infix Associativity Int

Instances

Instances details

Data Fixity #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Fixity -> c Fixity 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 :: forall r r'. (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 #
Generic Fixity #
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type Source # Methods from :: Fixity -> Rep Fixity x Source # to :: Rep Fixity x -> Fixity Source #
Read Fixity #	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS Fixity Source # readList :: ReadS [Fixity] Source # readPrec :: ReadPrec Fixity Source # readListPrec :: ReadPrec [Fixity] Source #
Show Fixity #	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Fixity -> ShowS Source # show :: Fixity -> String Source # showList :: [Fixity] -> ShowS Source #
Eq Fixity #	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Fixity -> Fixity -> Bool Source # (/=) :: Fixity -> Fixity -> Bool Source #
Ord Fixity #	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Fixity -> Fixity -> Ordering Source # (<) :: Fixity -> Fixity -> Bool Source # (<=) :: Fixity -> Fixity -> Bool Source # (>) :: Fixity -> Fixity -> Bool Source # (>=) :: Fixity -> Fixity -> Bool Source # max :: Fixity -> Fixity -> Fixity Source # min :: Fixity -> Fixity -> Fixity Source #
type Rep Fixity #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep Fixity = D1 ('MetaData "Fixity" "GHC.Generics" "base" 'False) (C1 ('MetaCons "Prefix" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Infix" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Associativity) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int)))

data FixityI Source #

This variant of Fixity appears at the type level.

Since: base-4.9.0.0

Constructors

PrefixI
InfixI Associativity Nat

data Associativity Source #

Datatype to represent the associativity of a constructor

Constructors

LeftAssociative
RightAssociative
NotAssociative

Instances

Instances details

Data Associativity #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Associativity -> c Associativity 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 :: forall r r'. (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 #
Bounded Associativity #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: Associativity Source # maxBound :: Associativity Source #
Enum Associativity #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: Associativity -> Associativity Source # pred :: Associativity -> Associativity Source # toEnum :: Int -> Associativity Source # fromEnum :: Associativity -> Int Source # enumFrom :: Associativity -> [Associativity] Source # enumFromThen :: Associativity -> Associativity -> [Associativity] Source # enumFromTo :: Associativity -> Associativity -> [Associativity] Source # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] Source #
Generic Associativity #
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type Source # Methods from :: Associativity -> Rep Associativity x Source # to :: Rep Associativity x -> Associativity Source #
Ix Associativity #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods range :: (Associativity, Associativity) -> [Associativity] Source # index :: (Associativity, Associativity) -> Associativity -> Int Source # unsafeIndex :: (Associativity, Associativity) -> Associativity -> Int Source # inRange :: (Associativity, Associativity) -> Associativity -> Bool Source # rangeSize :: (Associativity, Associativity) -> Int Source # unsafeRangeSize :: (Associativity, Associativity) -> Int Source #
Read Associativity #	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS Associativity Source # readList :: ReadS [Associativity] Source # readPrec :: ReadPrec Associativity Source # readListPrec :: ReadPrec [Associativity] Source #
Show Associativity #	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> Associativity -> ShowS Source # show :: Associativity -> String Source # showList :: [Associativity] -> ShowS Source #
Eq Associativity #	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods (==) :: Associativity -> Associativity -> Bool Source # (/=) :: Associativity -> Associativity -> Bool Source #
Ord Associativity #	Since: base-4.6.0.0
Instance details Defined in GHC.Generics Methods compare :: Associativity -> Associativity -> Ordering Source # (<) :: Associativity -> Associativity -> Bool Source # (<=) :: Associativity -> Associativity -> Bool Source # (>) :: Associativity -> Associativity -> Bool Source # (>=) :: Associativity -> Associativity -> Bool Source # max :: Associativity -> Associativity -> Associativity Source # min :: Associativity -> Associativity -> Associativity Source #
type Rep Associativity #	Since: base-4.7.0.0
Instance details Defined in GHC.Generics type Rep Associativity = D1 ('MetaData "Associativity" "GHC.Generics" "base" 'False) (C1 ('MetaCons "LeftAssociative" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "RightAssociative" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "NotAssociative" 'PrefixI 'False) (U1 :: Type -> Type)))

prec :: Fixity -> Int Source #

Get the precedence of a fixity value.

data SourceUnpackedness Source #

The unpackedness of a field as the user wrote it in the source code. For example, in the following data type:

data E = ExampleConstructor     Int
           {-# NOUNPACK #-} Int
           {-#   UNPACK #-} Int

The fields of ExampleConstructor have NoSourceUnpackedness, SourceNoUnpack, and SourceUnpack, respectively.

Since: base-4.9.0.0

Constructors

NoSourceUnpackedness
SourceNoUnpack
SourceUnpack

Instances

Instances details

Data SourceUnpackedness #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceUnpackedness -> c SourceUnpackedness 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 :: forall r r'. (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 #
Bounded SourceUnpackedness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceUnpackedness Source # maxBound :: SourceUnpackedness Source #
Enum SourceUnpackedness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness Source # pred :: SourceUnpackedness -> SourceUnpackedness Source # toEnum :: Int -> SourceUnpackedness Source # fromEnum :: SourceUnpackedness -> Int Source # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] Source # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] Source # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] Source # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] Source #
Generic SourceUnpackedness #
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type Source # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x Source # to :: Rep SourceUnpackedness x -> SourceUnpackedness Source #
Ix SourceUnpackedness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods range :: (SourceUnpackedness, SourceUnpackedness) -> [SourceUnpackedness] Source # index :: (SourceUnpackedness, SourceUnpackedness) -> SourceUnpackedness -> Int Source # unsafeIndex :: (SourceUnpackedness, SourceUnpackedness) -> SourceUnpackedness -> Int Source # inRange :: (SourceUnpackedness, SourceUnpackedness) -> SourceUnpackedness -> Bool Source # rangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int Source # unsafeRangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int Source #
Read SourceUnpackedness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS SourceUnpackedness Source # readList :: ReadS [SourceUnpackedness] Source # readPrec :: ReadPrec SourceUnpackedness Source # readListPrec :: ReadPrec [SourceUnpackedness] Source #
Show SourceUnpackedness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceUnpackedness -> ShowS Source # show :: SourceUnpackedness -> String Source # showList :: [SourceUnpackedness] -> ShowS Source #
Eq SourceUnpackedness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (/=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source #
Ord SourceUnpackedness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering Source # (<) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (<=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # (>=) :: SourceUnpackedness -> SourceUnpackedness -> Bool Source # max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source # min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness Source #
type Rep SourceUnpackedness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep SourceUnpackedness = D1 ('MetaData "SourceUnpackedness" "GHC.Generics" "base" 'False) (C1 ('MetaCons "NoSourceUnpackedness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceNoUnpack" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceUnpack" 'PrefixI 'False) (U1 :: Type -> Type)))

data SourceStrictness Source #

The strictness of a field as the user wrote it in the source code. For example, in the following data type:

data E = ExampleConstructor Int ~Int !Int

The fields of ExampleConstructor have NoSourceStrictness, SourceLazy, and SourceStrict, respectively.

Since: base-4.9.0.0

Constructors

NoSourceStrictness
SourceLazy
SourceStrict

Instances

Instances details

Data SourceStrictness #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SourceStrictness -> c SourceStrictness 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 :: forall r r'. (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 #
Bounded SourceStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: SourceStrictness Source # maxBound :: SourceStrictness Source #
Enum SourceStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness Source # pred :: SourceStrictness -> SourceStrictness Source # toEnum :: Int -> SourceStrictness Source # fromEnum :: SourceStrictness -> Int Source # enumFrom :: SourceStrictness -> [SourceStrictness] Source # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] Source # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] Source # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] Source #
Generic SourceStrictness #
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type Source # Methods from :: SourceStrictness -> Rep SourceStrictness x Source # to :: Rep SourceStrictness x -> SourceStrictness Source #
Ix SourceStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods range :: (SourceStrictness, SourceStrictness) -> [SourceStrictness] Source # index :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int Source # unsafeIndex :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int Source # inRange :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Bool Source # rangeSize :: (SourceStrictness, SourceStrictness) -> Int Source # unsafeRangeSize :: (SourceStrictness, SourceStrictness) -> Int Source #
Read SourceStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS SourceStrictness Source # readList :: ReadS [SourceStrictness] Source # readPrec :: ReadPrec SourceStrictness Source # readListPrec :: ReadPrec [SourceStrictness] Source #
Show SourceStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> SourceStrictness -> ShowS Source # show :: SourceStrictness -> String Source # showList :: [SourceStrictness] -> ShowS Source #
Eq SourceStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: SourceStrictness -> SourceStrictness -> Bool Source # (/=) :: SourceStrictness -> SourceStrictness -> Bool Source #
Ord SourceStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: SourceStrictness -> SourceStrictness -> Ordering Source # (<) :: SourceStrictness -> SourceStrictness -> Bool Source # (<=) :: SourceStrictness -> SourceStrictness -> Bool Source # (>) :: SourceStrictness -> SourceStrictness -> Bool Source # (>=) :: SourceStrictness -> SourceStrictness -> Bool Source # max :: SourceStrictness -> SourceStrictness -> SourceStrictness Source # min :: SourceStrictness -> SourceStrictness -> SourceStrictness Source #
type Rep SourceStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep SourceStrictness = D1 ('MetaData "SourceStrictness" "GHC.Generics" "base" 'False) (C1 ('MetaCons "NoSourceStrictness" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "SourceLazy" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SourceStrict" 'PrefixI 'False) (U1 :: Type -> Type)))

data DecidedStrictness Source #

The strictness that GHC infers for a field during compilation. Whereas there are nine different combinations of SourceUnpackedness and SourceStrictness, the strictness that GHC decides will ultimately be one of lazy, strict, or unpacked. What GHC decides is affected both by what the user writes in the source code and by GHC flags. As an example, consider this data type:

data E = ExampleConstructor {-# UNPACK #-} !Int !Int Int

If compiled without optimization or other language extensions, then the fields of ExampleConstructor will have DecidedStrict, DecidedStrict, and DecidedLazy, respectively.
If compiled with -XStrictData enabled, then the fields will have DecidedStrict, DecidedStrict, and DecidedStrict, respectively.
If compiled with -O2 enabled, then the fields will have DecidedUnpack, DecidedStrict, and DecidedLazy, respectively.

Since: base-4.9.0.0

Constructors

DecidedLazy
DecidedStrict
DecidedUnpack

Instances

Instances details

Data DecidedStrictness #	Since: base-4.9.0.0
Instance details Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> DecidedStrictness -> c DecidedStrictness 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 :: forall r r'. (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 #
Bounded DecidedStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods minBound :: DecidedStrictness Source # maxBound :: DecidedStrictness Source #
Enum DecidedStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness Source # pred :: DecidedStrictness -> DecidedStrictness Source # toEnum :: Int -> DecidedStrictness Source # fromEnum :: DecidedStrictness -> Int Source # enumFrom :: DecidedStrictness -> [DecidedStrictness] Source # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] Source # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] Source # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] Source #
Generic DecidedStrictness #
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type Source # Methods from :: DecidedStrictness -> Rep DecidedStrictness x Source # to :: Rep DecidedStrictness x -> DecidedStrictness Source #
Ix DecidedStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods range :: (DecidedStrictness, DecidedStrictness) -> [DecidedStrictness] Source # index :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int Source # unsafeIndex :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int Source # inRange :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Bool Source # rangeSize :: (DecidedStrictness, DecidedStrictness) -> Int Source # unsafeRangeSize :: (DecidedStrictness, DecidedStrictness) -> Int Source #
Read DecidedStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods readsPrec :: Int -> ReadS DecidedStrictness Source # readList :: ReadS [DecidedStrictness] Source # readPrec :: ReadPrec DecidedStrictness Source # readListPrec :: ReadPrec [DecidedStrictness] Source #
Show DecidedStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods showsPrec :: Int -> DecidedStrictness -> ShowS Source # show :: DecidedStrictness -> String Source # showList :: [DecidedStrictness] -> ShowS Source #
Eq DecidedStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods (==) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (/=) :: DecidedStrictness -> DecidedStrictness -> Bool Source #
Ord DecidedStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods compare :: DecidedStrictness -> DecidedStrictness -> Ordering Source # (<) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (<=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>) :: DecidedStrictness -> DecidedStrictness -> Bool Source # (>=) :: DecidedStrictness -> DecidedStrictness -> Bool Source # max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source # min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness Source #
type Rep DecidedStrictness #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics type Rep DecidedStrictness = D1 ('MetaData "DecidedStrictness" "GHC.Generics" "base" 'False) (C1 ('MetaCons "DecidedLazy" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "DecidedStrict" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "DecidedUnpack" 'PrefixI 'False) (U1 :: Type -> Type)))

data Meta Source #

Datatype to represent metadata associated with a datatype (MetaData), constructor (MetaCons), or field selector (MetaSel).

In MetaData n m p nt, n is the datatype's name, m is the module in which the datatype is defined, p is the package in which the datatype is defined, and nt is 'True if the datatype is a newtype.
In MetaCons n f s, n is the constructor's name, f is its fixity, and s is 'True if the constructor contains record selectors.
In MetaSel mn su ss ds, if the field uses record syntax, then mn is Just the record name. Otherwise, mn is Nothing. su and ss are the field's unpackedness and strictness annotations, and ds is the strictness that GHC infers for the field.

Since: base-4.9.0.0

Constructors

MetaData Symbol Symbol Symbol Bool
MetaCons Symbol FixityI Bool
MetaSel (Maybe Symbol) SourceUnpackedness SourceStrictness DecidedStrictness

Instances

Instances details

(KnownSymbol n, SingI f, SingI r) => Constructor ('MetaCons n f r :: Meta) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods conName :: forall k1 t (f0 :: k1 -> Type) (a :: k1). t ('MetaCons n f r) f0 a -> [Char] Source # conFixity :: forall k1 t (f0 :: k1 -> Type) (a :: k1). t ('MetaCons n f r) f0 a -> Fixity Source # conIsRecord :: forall k1 t (f0 :: k1 -> Type) (a :: k1). t ('MetaCons n f r) f0 a -> Bool Source #
(KnownSymbol n, KnownSymbol m, KnownSymbol p, SingI nt) => Datatype ('MetaData n m p nt :: Meta) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods datatypeName :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaData n m p nt) f a -> [Char] Source # moduleName :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaData n m p nt) f a -> [Char] Source # packageName :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaData n m p nt) f a -> [Char] Source # isNewtype :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaData n m p nt) f a -> Bool Source #
(SingI mn, SingI su, SingI ss, SingI ds) => Selector ('MetaSel mn su ss ds :: Meta) #	Since: base-4.9.0.0
Instance details Defined in GHC.Generics Methods selName :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaSel mn su ss ds) f a -> [Char] Source # selSourceUnpackedness :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaSel mn su ss ds) f a -> SourceUnpackedness Source # selSourceStrictness :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaSel mn su ss ds) f a -> SourceStrictness Source # selDecidedStrictness :: forall k1 t (f :: k1 -> Type) (a :: k1). t ('MetaSel mn su ss ds) f a -> DecidedStrictness Source #

Generic type classes

class Generic a where Source #

Representable types of kind *. This class is derivable in GHC with the DeriveGeneric flag on.

A Generic instance must satisfy the following laws:

from . to ≡ id
to . from ≡ id

Associated Types

type Rep a :: Type -> Type Source #

Generic representation type

Methods

from :: a -> Rep a x Source #

Convert from the datatype to its representation

to :: Rep a x -> a Source #

Convert from the representation to the datatype

Instances

Instances details

Generic All #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep All :: Type -> Type Source # Methods from :: All -> Rep All x Source # to :: Rep All x -> All Source #
Generic Any #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep Any :: Type -> Type Source # Methods from :: Any -> Rep Any x Source # to :: Rep Any x -> Any Source #
Generic Version #
Instance details Defined in Data.Version Associated Types type Rep Version :: Type -> Type Source # Methods from :: Version -> Rep Version x Source # to :: Rep Version x -> Version Source #
Generic Void #
Instance details Defined in Data.Void Associated Types type Rep Void :: Type -> Type Source # Methods from :: Void -> Rep Void x Source # to :: Rep Void x -> Void Source #
Generic ByteOrder #
Instance details Defined in GHC.ByteOrder Associated Types type Rep ByteOrder :: Type -> Type Source # Methods from :: ByteOrder -> Rep ByteOrder x Source # to :: Rep ByteOrder x -> ByteOrder Source #
Generic Fingerprint #
Instance details Defined in GHC.Generics Associated Types type Rep Fingerprint :: Type -> Type Source # Methods from :: Fingerprint -> Rep Fingerprint x Source # to :: Rep Fingerprint x -> Fingerprint Source #
Generic Associativity #
Instance details Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type Source # Methods from :: Associativity -> Rep Associativity x Source # to :: Rep Associativity x -> Associativity Source #
Generic DecidedStrictness #
Instance details Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type Source # Methods from :: DecidedStrictness -> Rep DecidedStrictness x Source # to :: Rep DecidedStrictness x -> DecidedStrictness Source #
Generic Fixity #
Instance details Defined in GHC.Generics Associated Types type Rep Fixity :: Type -> Type Source # Methods from :: Fixity -> Rep Fixity x Source # to :: Rep Fixity x -> Fixity Source #
Generic SourceStrictness #
Instance details Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type Source # Methods from :: SourceStrictness -> Rep SourceStrictness x Source # to :: Rep SourceStrictness x -> SourceStrictness Source #
Generic SourceUnpackedness #
Instance details Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type Source # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x Source # to :: Rep SourceUnpackedness x -> SourceUnpackedness Source #
Generic ExitCode #
Instance details Defined in GHC.IO.Exception Associated Types type Rep ExitCode :: Type -> Type Source # Methods from :: ExitCode -> Rep ExitCode x Source # to :: Rep ExitCode x -> ExitCode Source #
Generic CCFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep CCFlags :: Type -> Type Source # Methods from :: CCFlags -> Rep CCFlags x Source # to :: Rep CCFlags x -> CCFlags Source #
Generic ConcFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ConcFlags :: Type -> Type Source # Methods from :: ConcFlags -> Rep ConcFlags x Source # to :: Rep ConcFlags x -> ConcFlags Source #
Generic DebugFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DebugFlags :: Type -> Type Source # Methods from :: DebugFlags -> Rep DebugFlags x Source # to :: Rep DebugFlags x -> DebugFlags Source #
Generic DoCostCentres #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoCostCentres :: Type -> Type Source # Methods from :: DoCostCentres -> Rep DoCostCentres x Source # to :: Rep DoCostCentres x -> DoCostCentres Source #
Generic DoHeapProfile #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoHeapProfile :: Type -> Type Source # Methods from :: DoHeapProfile -> Rep DoHeapProfile x Source # to :: Rep DoHeapProfile x -> DoHeapProfile Source #
Generic DoTrace #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep DoTrace :: Type -> Type Source # Methods from :: DoTrace -> Rep DoTrace x Source # to :: Rep DoTrace x -> DoTrace Source #
Generic GCFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GCFlags :: Type -> Type Source # Methods from :: GCFlags -> Rep GCFlags x Source # to :: Rep GCFlags x -> GCFlags Source #
Generic GiveGCStats #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep GiveGCStats :: Type -> Type Source # Methods from :: GiveGCStats -> Rep GiveGCStats x Source # to :: Rep GiveGCStats x -> GiveGCStats Source #
Generic MiscFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep MiscFlags :: Type -> Type Source # Methods from :: MiscFlags -> Rep MiscFlags x Source # to :: Rep MiscFlags x -> MiscFlags Source #
Generic ParFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ParFlags :: Type -> Type Source # Methods from :: ParFlags -> Rep ParFlags x Source # to :: Rep ParFlags x -> ParFlags Source #
Generic ProfFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep ProfFlags :: Type -> Type Source # Methods from :: ProfFlags -> Rep ProfFlags x Source # to :: Rep ProfFlags x -> ProfFlags Source #
Generic RTSFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep RTSFlags :: Type -> Type Source # Methods from :: RTSFlags -> Rep RTSFlags x Source # to :: Rep RTSFlags x -> RTSFlags Source #
Generic TickyFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TickyFlags :: Type -> Type Source # Methods from :: TickyFlags -> Rep TickyFlags x Source # to :: Rep TickyFlags x -> TickyFlags Source #
Generic TraceFlags #
Instance details Defined in GHC.RTS.Flags Associated Types type Rep TraceFlags :: Type -> Type Source # Methods from :: TraceFlags -> Rep TraceFlags x Source # to :: Rep TraceFlags x -> TraceFlags Source #
Generic SrcLoc #
Instance details Defined in GHC.Generics Associated Types type Rep SrcLoc :: Type -> Type Source # Methods from :: SrcLoc -> Rep SrcLoc x Source # to :: Rep SrcLoc x -> SrcLoc Source #
Generic GCDetails #
Instance details Defined in GHC.Stats Associated Types type Rep GCDetails :: Type -> Type Source # Methods from :: GCDetails -> Rep GCDetails x Source # to :: Rep GCDetails x -> GCDetails Source #
Generic RTSStats #
Instance details Defined in GHC.Stats Associated Types type Rep RTSStats :: Type -> Type Source # Methods from :: RTSStats -> Rep RTSStats x Source # to :: Rep RTSStats x -> RTSStats Source #
Generic GeneralCategory #
Instance details Defined in GHC.Generics Associated Types type Rep GeneralCategory :: Type -> Type Source # Methods from :: GeneralCategory -> Rep GeneralCategory x Source # to :: Rep GeneralCategory x -> GeneralCategory Source #
Generic Ordering #
Instance details Defined in GHC.Generics Associated Types type Rep Ordering :: Type -> Type Source # Methods from :: Ordering -> Rep Ordering x Source # to :: Rep Ordering x -> Ordering Source #
Generic () #
Instance details Defined in GHC.Generics Associated Types type Rep () :: Type -> Type Source # Methods from :: () -> Rep () x Source # to :: Rep () x -> () Source #
Generic Bool #
Instance details Defined in GHC.Generics Associated Types type Rep Bool :: Type -> Type Source # Methods from :: Bool -> Rep Bool x Source # to :: Rep Bool x -> Bool Source #
Generic (ZipList a) #
Instance details Defined in Control.Applicative Associated Types type Rep (ZipList a) :: Type -> Type Source # Methods from :: ZipList a -> Rep (ZipList a) x Source # to :: Rep (ZipList a) x -> ZipList a Source #
Generic (Complex a) #
Instance details Defined in Data.Complex Associated Types type Rep (Complex a) :: Type -> Type Source # Methods from :: Complex a -> Rep (Complex a) x Source # to :: Rep (Complex a) x -> Complex a Source #
Generic (Identity a) #
Instance details Defined in Data.Functor.Identity Associated Types type Rep (Identity a) :: Type -> Type Source # Methods from :: Identity a -> Rep (Identity a) x Source # to :: Rep (Identity a) x -> Identity a Source #
Generic (First a) #
Instance details Defined in Data.Monoid Associated Types type Rep (First a) :: Type -> Type Source # Methods from :: First a -> Rep (First a) x Source # to :: Rep (First a) x -> First a Source #
Generic (Last a) #
Instance details Defined in Data.Monoid Associated Types type Rep (Last a) :: Type -> Type Source # Methods from :: Last a -> Rep (Last a) x Source # to :: Rep (Last a) x -> Last a Source #
Generic (Down a) #
Instance details Defined in GHC.Generics Associated Types type Rep (Down a) :: Type -> Type Source # Methods from :: Down a -> Rep (Down a) x Source # to :: Rep (Down a) x -> Down a Source #
Generic (First a) #
Instance details Defined in Data.Semigroup Associated Types type Rep (First a) :: Type -> Type Source # Methods from :: First a -> Rep (First a) x Source # to :: Rep (First a) x -> First a Source #
Generic (Last a) #
Instance details Defined in Data.Semigroup Associated Types type Rep (Last a) :: Type -> Type Source # Methods from :: Last a -> Rep (Last a) x Source # to :: Rep (Last a) x -> Last a Source #
Generic (Max a) #
Instance details Defined in Data.Semigroup Associated Types type Rep (Max a) :: Type -> Type Source # Methods from :: Max a -> Rep (Max a) x Source # to :: Rep (Max a) x -> Max a Source #
Generic (Min a) #
Instance details Defined in Data.Semigroup Associated Types type Rep (Min a) :: Type -> Type Source # Methods from :: Min a -> Rep (Min a) x Source # to :: Rep (Min a) x -> Min a Source #
Generic (WrappedMonoid m) #
Instance details Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type Source # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x Source # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m Source #
Generic (Dual a) #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Dual a) :: Type -> Type Source # Methods from :: Dual a -> Rep (Dual a) x Source # to :: Rep (Dual a) x -> Dual a Source #
Generic (Endo a) #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Endo a) :: Type -> Type Source # Methods from :: Endo a -> Rep (Endo a) x Source # to :: Rep (Endo a) x -> Endo a Source #
Generic (Product a) #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Product a) :: Type -> Type Source # Methods from :: Product a -> Rep (Product a) x Source # to :: Rep (Product a) x -> Product a Source #
Generic (Sum a) #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Sum a) :: Type -> Type Source # Methods from :: Sum a -> Rep (Sum a) x Source # to :: Rep (Sum a) x -> Sum a Source #
Generic (Par1 p) #
Instance details Defined in GHC.Generics Associated Types type Rep (Par1 p) :: Type -> Type Source # Methods from :: Par1 p -> Rep (Par1 p) x Source # to :: Rep (Par1 p) x -> Par1 p Source #
Generic (NonEmpty a) #
Instance details Defined in GHC.Generics Associated Types type Rep (NonEmpty a) :: Type -> Type Source # Methods from :: NonEmpty a -> Rep (NonEmpty a) x Source # to :: Rep (NonEmpty a) x -> NonEmpty a Source #
Generic (Maybe a) #
Instance details Defined in GHC.Generics Associated Types type Rep (Maybe a) :: Type -> Type Source # Methods from :: Maybe a -> Rep (Maybe a) x Source # to :: Rep (Maybe a) x -> Maybe a Source #
Generic (a) #
Instance details Defined in GHC.Generics Associated Types type Rep (a) :: Type -> Type Source # Methods from :: (a) -> Rep (a) x Source # to :: Rep (a) x -> (a) Source #
Generic [a] #
Instance details Defined in GHC.Generics Associated Types type Rep [a] :: Type -> Type Source # Methods from :: [a] -> Rep [a] x Source # to :: Rep [a] x -> [a] Source #
Generic (WrappedMonad m a) #
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type Source # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x Source # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a Source #
Generic (Either a b) #
Instance details Defined in GHC.Generics Associated Types type Rep (Either a b) :: Type -> Type Source # Methods from :: Either a b -> Rep (Either a b) x Source # to :: Rep (Either a b) x -> Either a b Source #
Generic (Proxy t) #
Instance details Defined in GHC.Generics Associated Types type Rep (Proxy t) :: Type -> Type Source # Methods from :: Proxy t -> Rep (Proxy t) x Source # to :: Rep (Proxy t) x -> Proxy t Source #
Generic (Arg a b) #
Instance details Defined in Data.Semigroup Associated Types type Rep (Arg a b) :: Type -> Type Source # Methods from :: Arg a b -> Rep (Arg a b) x Source # to :: Rep (Arg a b) x -> Arg a b Source #
Generic (U1 p) #
Instance details Defined in GHC.Generics Associated Types type Rep (U1 p) :: Type -> Type Source # Methods from :: U1 p -> Rep (U1 p) x Source # to :: Rep (U1 p) x -> U1 p Source #
Generic (V1 p) #
Instance details Defined in GHC.Generics Associated Types type Rep (V1 p) :: Type -> Type Source # Methods from :: V1 p -> Rep (V1 p) x Source # to :: Rep (V1 p) x -> V1 p Source #
Generic (a, b) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b) :: Type -> Type Source # Methods from :: (a, b) -> Rep (a, b) x Source # to :: Rep (a, b) x -> (a, b) Source #
Generic (WrappedArrow a b c) #
Instance details Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type 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 (Kleisli m a b) #
Instance details Defined in Control.Arrow Associated Types type Rep (Kleisli m a b) :: Type -> Type Source # Methods from :: Kleisli m a b -> Rep (Kleisli m a b) x Source # to :: Rep (Kleisli m a b) x -> Kleisli m a b Source #
Generic (Const a b) #
Instance details Defined in Data.Functor.Const Associated Types type Rep (Const a b) :: Type -> Type Source # Methods from :: Const a b -> Rep (Const a b) x Source # to :: Rep (Const a b) x -> Const a b Source #
Generic (Ap f a) #
Instance details Defined in Data.Monoid Associated Types type Rep (Ap f a) :: Type -> Type Source # Methods from :: Ap f a -> Rep (Ap f a) x Source # to :: Rep (Ap f a) x -> Ap f a Source #
Generic (Alt f a) #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep (Alt f a) :: Type -> Type Source # Methods from :: Alt f a -> Rep (Alt f a) x Source # to :: Rep (Alt f a) x -> Alt f a Source #
Generic (Rec1 f p) #
Instance details Defined in GHC.Generics Associated Types type Rep (Rec1 f p) :: Type -> Type Source # Methods from :: Rec1 f p -> Rep (Rec1 f p) x Source # to :: Rep (Rec1 f p) x -> Rec1 f p Source #
Generic (URec (Ptr ()) p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec (Ptr ()) p) :: Type -> Type Source # Methods from :: URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x Source # to :: Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p Source #
Generic (URec Char p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Char p) :: Type -> Type Source # Methods from :: URec Char p -> Rep (URec Char p) x Source # to :: Rep (URec Char p) x -> URec Char p Source #
Generic (URec Double p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Double p) :: Type -> Type Source # Methods from :: URec Double p -> Rep (URec Double p) x Source # to :: Rep (URec Double p) x -> URec Double p Source #
Generic (URec Float p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Float p) :: Type -> Type Source # Methods from :: URec Float p -> Rep (URec Float p) x Source # to :: Rep (URec Float p) x -> URec Float p Source #
Generic (URec Int p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Int p) :: Type -> Type Source # Methods from :: URec Int p -> Rep (URec Int p) x Source # to :: Rep (URec Int p) x -> URec Int p Source #
Generic (URec Word p) #
Instance details Defined in GHC.Generics Associated Types type Rep (URec Word p) :: Type -> Type Source # Methods from :: URec Word p -> Rep (URec Word p) x Source # to :: Rep (URec Word p) x -> URec Word p Source #
Generic (a, b, c) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c) :: Type -> Type Source # Methods from :: (a, b, c) -> Rep (a, b, c) x Source # to :: Rep (a, b, c) x -> (a, b, c) Source #
Generic (Product f g a) #
Instance details Defined in Data.Functor.Product Associated Types type Rep (Product f g a) :: Type -> Type Source # Methods from :: Product f g a -> Rep (Product f g a) x Source # to :: Rep (Product f g a) x -> Product f g a Source #
Generic (Sum f g a) #
Instance details Defined in Data.Functor.Sum Associated Types type Rep (Sum f g a) :: Type -> Type Source # Methods from :: Sum f g a -> Rep (Sum f g a) x Source # to :: Rep (Sum f g a) x -> Sum f g a Source #
Generic ((f :*: g) p) #
Instance details Defined in GHC.Generics Associated Types type Rep ((f :: g) p) :: Type -> Type Source # Methods from :: (f :: g) p -> Rep ((f :: g) p) x Source # to :: Rep ((f :: g) p) x -> (f :*: g) p Source #
Generic ((f :+: g) p) #
Instance details Defined in GHC.Generics Associated Types type Rep ((f :+: g) p) :: Type -> Type Source # Methods from :: (f :+: g) p -> Rep ((f :+: g) p) x Source # to :: Rep ((f :+: g) p) x -> (f :+: g) p Source #
Generic (K1 i c p) #
Instance details Defined in GHC.Generics Associated Types type Rep (K1 i c p) :: Type -> Type Source # Methods from :: K1 i c p -> Rep (K1 i c p) x Source # to :: Rep (K1 i c p) x -> K1 i c p Source #
Generic (a, b, c, d) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d) :: Type -> Type 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 (Compose f g a) #
Instance details Defined in Data.Functor.Compose Associated Types type Rep (Compose f g a) :: Type -> Type Source # Methods from :: Compose f g a -> Rep (Compose f g a) x Source # to :: Rep (Compose f g a) x -> Compose f g a Source #
Generic ((f :.: g) p) #
Instance details Defined in GHC.Generics Associated Types type Rep ((f :.: g) p) :: Type -> Type Source # Methods from :: (f :.: g) p -> Rep ((f :.: g) p) x Source # to :: Rep ((f :.: g) p) x -> (f :.: g) p Source #
Generic (M1 i c f p) #
Instance details Defined in GHC.Generics Associated Types type Rep (M1 i c f p) :: Type -> Type Source # Methods from :: M1 i c f p -> Rep (M1 i c f p) x Source # to :: Rep (M1 i c f p) x -> M1 i c f p Source #
Generic (a, b, c, d, e) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e) :: Type -> Type 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 (a, b, c, d, e, f) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f) :: Type -> Type 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) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g) :: Type -> Type 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 #
Generic (a, b, c, d, e, f, g, h) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h) -> Rep (a, b, c, d, e, f, g, h) x Source # to :: Rep (a, b, c, d, e, f, g, h) x -> (a, b, c, d, e, f, g, h) Source #
Generic (a, b, c, d, e, f, g, h, i) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i) -> Rep (a, b, c, d, e, f, g, h, i) x Source # to :: Rep (a, b, c, d, e, f, g, h, i) x -> (a, b, c, d, e, f, g, h, i) Source #
Generic (a, b, c, d, e, f, g, h, i, j) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j) -> Rep (a, b, c, d, e, f, g, h, i, j) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j) x -> (a, b, c, d, e, f, g, h, i, j) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k) -> Rep (a, b, c, d, e, f, g, h, i, j, k) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k) x -> (a, b, c, d, e, f, g, h, i, j, k) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k, l) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k, l) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l) x -> (a, b, c, d, e, f, g, h, i, j, k, l) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) Source #
Generic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) #
Instance details Defined in GHC.Generics Associated Types type Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: Type -> Type Source # Methods from :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x Source # to :: Rep (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) x -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) Source #

class Generic1 (f :: k -> Type) where Source #

Representable types of kind * -> * (or kind k -> *, when PolyKinds is enabled). This class is derivable in GHC with the DeriveGeneric flag on.

A Generic1 instance must satisfy the following laws:

from1 . to1 ≡ id
to1 . from1 ≡ id

Associated Types

type Rep1 f :: k -> Type Source #

Generic representation type

Methods

from1 :: f a -> Rep1 f a Source #

Convert from the datatype to its representation

to1 :: Rep1 f a -> f a Source #

Convert from the representation to the datatype

Instances

Instances details

Generic1 ZipList #
Instance details Defined in Control.Applicative Associated Types type Rep1 ZipList :: k -> Type Source # Methods from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a Source # to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a Source #
Generic1 Complex #
Instance details Defined in Data.Complex Associated Types type Rep1 Complex :: k -> Type Source # Methods from1 :: forall (a :: k). Complex a -> Rep1 Complex a Source # to1 :: forall (a :: k). Rep1 Complex a -> Complex a Source #
Generic1 Identity #
Instance details Defined in Data.Functor.Identity Associated Types type Rep1 Identity :: k -> Type Source # Methods from1 :: forall (a :: k). Identity a -> Rep1 Identity a Source # to1 :: forall (a :: k). Rep1 Identity a -> Identity a Source #
Generic1 Down #
Instance details Defined in GHC.Generics Associated Types type Rep1 Down :: k -> Type Source # Methods from1 :: forall (a :: k). Down a -> Rep1 Down a Source # to1 :: forall (a :: k). Rep1 Down a -> Down a Source #
Generic1 NonEmpty #
Instance details Defined in GHC.Generics Associated Types type Rep1 NonEmpty :: k -> Type Source # Methods from1 :: forall (a :: k). NonEmpty a -> Rep1 NonEmpty a Source # to1 :: forall (a :: k). Rep1 NonEmpty a -> NonEmpty a Source #
Generic1 Maybe #
Instance details Defined in GHC.Generics Associated Types type Rep1 Maybe :: k -> Type Source # Methods from1 :: forall (a :: k). Maybe a -> Rep1 Maybe a Source # to1 :: forall (a :: k). Rep1 Maybe a -> Maybe a Source #
Generic1 Solo #
Instance details Defined in GHC.Generics Associated Types type Rep1 Solo :: k -> Type Source # Methods from1 :: forall (a :: k). Solo a -> Rep1 Solo a Source # to1 :: forall (a :: k). Rep1 Solo a -> Solo a Source #
Generic1 [] #
Instance details Defined in GHC.Generics Associated Types type Rep1 [] :: k -> Type Source # Methods from1 :: forall (a :: k). [a] -> Rep1 [] a Source # to1 :: forall (a :: k). Rep1 [] a -> [a] Source #
Generic1 (WrappedMonad m :: Type -> Type) #
Instance details Defined in Control.Applicative Associated Types type Rep1 (WrappedMonad m) :: k -> Type Source # Methods from1 :: forall (a :: k). WrappedMonad m a -> Rep1 (WrappedMonad m) a Source # to1 :: forall (a :: k). Rep1 (WrappedMonad m) a -> WrappedMonad m a Source #
Generic1 (Either a :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (Either a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Either a a0 -> Rep1 (Either a) a0 Source # to1 :: forall (a0 :: k). Rep1 (Either a) a0 -> Either a a0 Source #
Generic1 ((,) a :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,) a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, a0) -> Rep1 ((,) a) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,) a) a0 -> (a, a0) Source #
Generic1 (Proxy :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 Proxy :: k -> Type Source # Methods from1 :: forall (a :: k0). Proxy a -> Rep1 Proxy a Source # to1 :: forall (a :: k0). Rep1 Proxy a -> Proxy a Source #
Generic1 (U1 :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 U1 :: k -> Type Source # Methods from1 :: forall (a :: k0). U1 a -> Rep1 U1 a Source # to1 :: forall (a :: k0). Rep1 U1 a -> U1 a Source #
Generic1 (V1 :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 V1 :: k -> Type Source # Methods from1 :: forall (a :: k0). V1 a -> Rep1 V1 a Source # to1 :: forall (a :: k0). Rep1 V1 a -> V1 a Source #
Generic1 (WrappedArrow a b :: Type -> Type) #
Instance details Defined in Control.Applicative Associated Types type Rep1 (WrappedArrow a b) :: k -> Type Source # Methods from1 :: forall (a0 :: k). WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0 Source # to1 :: forall (a0 :: k). Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0 Source #
Generic1 (Kleisli m a :: Type -> TYPE LiftedRep) #
Instance details Defined in Control.Arrow Associated Types type Rep1 (Kleisli m a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Kleisli m a a0 -> Rep1 (Kleisli m a) a0 Source # to1 :: forall (a0 :: k). Rep1 (Kleisli m a) a0 -> Kleisli m a a0 Source #
Generic1 ((,,) a b :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,) a b) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, a0) -> Rep1 ((,,) a b) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,,) a b) a0 -> (a, b, a0) Source #
Generic1 (Const a :: k -> Type) #
Instance details Defined in Data.Functor.Const Associated Types type Rep1 (Const a) :: k -> Type Source # Methods from1 :: forall (a0 :: k0). Const a a0 -> Rep1 (Const a) a0 Source # to1 :: forall (a0 :: k0). Rep1 (Const a) a0 -> Const a a0 Source #
Generic1 (Ap f :: k -> Type) #
Instance details Defined in Data.Monoid Associated Types type Rep1 (Ap f) :: k -> Type Source # Methods from1 :: forall (a :: k0). Ap f a -> Rep1 (Ap f) a Source # to1 :: forall (a :: k0). Rep1 (Ap f) a -> Ap f a Source #
Generic1 (Alt f :: k -> Type) #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 (Alt f) :: k -> Type Source # Methods from1 :: forall (a :: k0). Alt f a -> Rep1 (Alt f) a Source # to1 :: forall (a :: k0). Rep1 (Alt f) a -> Alt f a Source #
Generic1 (Rec1 f :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (Rec1 f) :: k -> Type Source # Methods from1 :: forall (a :: k0). Rec1 f a -> Rep1 (Rec1 f) a Source # to1 :: forall (a :: k0). Rep1 (Rec1 f) a -> Rec1 f a Source #
Generic1 (URec (Ptr ()) :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec (Ptr ())) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a Source # to1 :: forall (a :: k0). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a Source #
Generic1 (URec Char :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Char) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Char a -> Rep1 (URec Char) a Source # to1 :: forall (a :: k0). Rep1 (URec Char) a -> URec Char a Source #
Generic1 (URec Double :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Double) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Double a -> Rep1 (URec Double) a Source # to1 :: forall (a :: k0). Rep1 (URec Double) a -> URec Double a Source #
Generic1 (URec Float :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Float) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Float a -> Rep1 (URec Float) a Source # to1 :: forall (a :: k0). Rep1 (URec Float) a -> URec Float a Source #
Generic1 (URec Int :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Int) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Int a -> Rep1 (URec Int) a Source # to1 :: forall (a :: k0). Rep1 (URec Int) a -> URec Int a Source #
Generic1 (URec Word :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (URec Word) :: k -> Type Source # Methods from1 :: forall (a :: k0). URec Word a -> Rep1 (URec Word) a Source # to1 :: forall (a :: k0). Rep1 (URec Word) a -> URec Word a Source #
Generic1 ((,,,) a b c :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,) a b c) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, a0) -> Rep1 ((,,,) a b c) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,,,) a b c) a0 -> (a, b, c, a0) Source #
Generic1 (Product f g :: k -> Type) #
Instance details Defined in Data.Functor.Product Associated Types type Rep1 (Product f g) :: k -> Type Source # Methods from1 :: forall (a :: k0). Product f g a -> Rep1 (Product f g) a Source # to1 :: forall (a :: k0). Rep1 (Product f g) a -> Product f g a Source #
Generic1 (Sum f g :: k -> Type) #
Instance details Defined in Data.Functor.Sum Associated Types type Rep1 (Sum f g) :: k -> Type Source # Methods from1 :: forall (a :: k0). Sum f g a -> Rep1 (Sum f g) a Source # to1 :: forall (a :: k0). Rep1 (Sum f g) a -> Sum f g a Source #
Generic1 (f :*: g :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :: g) a -> Rep1 (f :: g) a Source # to1 :: forall (a :: k0). Rep1 (f :: g) a -> (f :*: g) a Source #
Generic1 (f :+: g :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :+: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :+: g) a -> Rep1 (f :+: g) a Source # to1 :: forall (a :: k0). Rep1 (f :+: g) a -> (f :+: g) a Source #
Generic1 (K1 i c :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (K1 i c) :: k -> Type Source # Methods from1 :: forall (a :: k0). K1 i c a -> Rep1 (K1 i c) a Source # to1 :: forall (a :: k0). Rep1 (K1 i c) a -> K1 i c a Source #
Generic1 ((,,,,) a b c d :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,) a b c d) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, a0) -> Rep1 ((,,,,) a b c d) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,,,,) a b c d) a0 -> (a, b, c, d, a0) Source #
Functor f => Generic1 (Compose f g :: k -> Type) #
Instance details Defined in Data.Functor.Compose Associated Types type Rep1 (Compose f g) :: k -> Type Source # Methods from1 :: forall (a :: k0). Compose f g a -> Rep1 (Compose f g) a Source # to1 :: forall (a :: k0). Rep1 (Compose f g) a -> Compose f g a Source #
Functor f => Generic1 (f :.: g :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (f :.: g) :: k -> Type Source # Methods from1 :: forall (a :: k0). (f :.: g) a -> Rep1 (f :.: g) a Source # to1 :: forall (a :: k0). Rep1 (f :.: g) a -> (f :.: g) a Source #
Generic1 (M1 i c f :: k -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 (M1 i c f) :: k -> Type Source # Methods from1 :: forall (a :: k0). M1 i c f a -> Rep1 (M1 i c f) a Source # to1 :: forall (a :: k0). Rep1 (M1 i c f) a -> M1 i c f a Source #
Generic1 ((,,,,,) a b c d e :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,) a b c d e) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, a0) -> Rep1 ((,,,,,) a b c d e) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,,,,,) a b c d e) a0 -> (a, b, c, d, e, a0) Source #
Generic1 ((,,,,,,) a b c d e f :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,) a b c d e f) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, f, a0) -> Rep1 ((,,,,,,) a b c d e f) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,,,,,,) a b c d e f) a0 -> (a, b, c, d, e, f, a0) Source #
Generic1 ((,,,,,,,) a b c d e f g :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,,) a b c d e f g) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, a0) -> Rep1 ((,,,,,,,) a b c d e f g) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,,,,,,,) a b c d e f g) a0 -> (a, b, c, d, e, f, g, a0) Source #
Generic1 ((,,,,,,,,) a b c d e f g h :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,,,) a b c d e f g h) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, h, a0) -> Rep1 ((,,,,,,,,) a b c d e f g h) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,,,,,,,,) a b c d e f g h) a0 -> (a, b, c, d, e, f, g, h, a0) Source #
Generic1 ((,,,,,,,,,) a b c d e f g h i :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,,,,) a b c d e f g h i) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, h, i, a0) -> Rep1 ((,,,,,,,,,) a b c d e f g h i) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,,,,,,,,,) a b c d e f g h i) a0 -> (a, b, c, d, e, f, g, h, i, a0) Source #
Generic1 ((,,,,,,,,,,) a b c d e f g h i j :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,,,,,) a b c d e f g h i j) :: k -> Type Source # Methods from1 :: forall (a0 :: k). (a, b, c, d, e, f, g, h, i, j, a0) -> Rep1 ((,,,,,,,,,,) a b c d e f g h i j) a0 Source # to1 :: forall (a0 :: k). Rep1 ((,,,,,,,,,,) a b c d e f g h i j) a0 -> (a, b, c, d, e, f, g, h, i, j, a0) Source #
Generic1 ((,,,,,,,,,,,) a b c d e f g h i j k :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) :: k -> Type Source # Methods from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, a0) -> Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) a0 Source # to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,) a b c d e f g h i j k) a0 -> (a, b, c, d, e, f, g, h, i, j, k, a0) Source #
Generic1 ((,,,,,,,,,,,,) a b c d e f g h i j k l :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) :: k -> Type Source # Methods from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) a0 Source # to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,,) a b c d e f g h i j k l) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, a0) Source #
Generic1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) :: k -> Type Source # Methods from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) a0 Source # to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) Source #
Generic1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n :: Type -> Type) #
Instance details Defined in GHC.Generics Associated Types type Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) :: k -> Type Source # Methods from1 :: forall (a0 :: k0). (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) a0 Source # to1 :: forall (a0 :: k0). Rep1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n) a0 -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) Source #
Generic1 First #
Instance details Defined in Data.Monoid Associated Types type Rep1 First :: k -> Type Source # Methods from1 :: forall (a :: k). First a -> Rep1 First a Source # to1 :: forall (a :: k). Rep1 First a -> First a Source #
Generic1 Last #
Instance details Defined in Data.Monoid Associated Types type Rep1 Last :: k -> Type Source # Methods from1 :: forall (a :: k). Last a -> Rep1 Last a Source # to1 :: forall (a :: k). Rep1 Last a -> Last a Source #
Generic1 First #
Instance details Defined in Data.Semigroup Associated Types type Rep1 First :: k -> Type Source # Methods from1 :: forall (a :: k). First a -> Rep1 First a Source # to1 :: forall (a :: k). Rep1 First a -> First a Source #
Generic1 Last #
Instance details Defined in Data.Semigroup Associated Types type Rep1 Last :: k -> Type Source # Methods from1 :: forall (a :: k). Last a -> Rep1 Last a Source # to1 :: forall (a :: k). Rep1 Last a -> Last a Source #
Generic1 Max #
Instance details Defined in Data.Semigroup Associated Types type Rep1 Max :: k -> Type Source # Methods from1 :: forall (a :: k). Max a -> Rep1 Max a Source # to1 :: forall (a :: k). Rep1 Max a -> Max a Source #
Generic1 Min #
Instance details Defined in Data.Semigroup Associated Types type Rep1 Min :: k -> Type Source # Methods from1 :: forall (a :: k). Min a -> Rep1 Min a Source # to1 :: forall (a :: k). Rep1 Min a -> Min a Source #
Generic1 WrappedMonoid #
Instance details Defined in Data.Semigroup Associated Types type Rep1 WrappedMonoid :: k -> Type Source # Methods from1 :: forall (a :: k). WrappedMonoid a -> Rep1 WrappedMonoid a Source # to1 :: forall (a :: k). Rep1 WrappedMonoid a -> WrappedMonoid a Source #
Generic1 Dual #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Dual :: k -> Type Source # Methods from1 :: forall (a :: k). Dual a -> Rep1 Dual a Source # to1 :: forall (a :: k). Rep1 Dual a -> Dual a Source #
Generic1 Product #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Product :: k -> Type Source # Methods from1 :: forall (a :: k). Product a -> Rep1 Product a Source # to1 :: forall (a :: k). Rep1 Product a -> Product a Source #
Generic1 Sum #
Instance details Defined in Data.Semigroup.Internal Associated Types type Rep1 Sum :: k -> Type Source # Methods from1 :: forall (a :: k). Sum a -> Rep1 Sum a Source # to1 :: forall (a :: k). Rep1 Sum a -> Sum a Source #
Generic1 Par1 #
Instance details Defined in GHC.Generics Associated Types type Rep1 Par1 :: k -> Type Source # Methods from1 :: forall (a :: k). Par1 a -> Rep1 Par1 a Source # to1 :: forall (a :: k). Rep1 Par1 a -> Par1 a Source #
Generic1 (Arg a :: Type -> Type) #
Instance details Defined in Data.Semigroup Associated Types type Rep1 (Arg a) :: k -> Type Source # Methods from1 :: forall (a0 :: k). Arg a a0 -> Rep1 (Arg a) a0 Source # to1 :: forall (a0 :: k). Rep1 (Arg a) a0 -> Arg a a0 Source #

Introduction

Representing datatypes

Derived and fundamental representation types

Individual fields of constructors: K1

Meta information: M1

Additional generic representation type constructors

Empty datatypes: V1

Constructors without fields: U1

Representation of types with many constructors or many fields

Defining datatype-generic functions

Definition of the generic representation types

Generic instances

The wrapper and generic default

Omitting generic instances

Generic constructor classes

The Generic1 class

Representation of * -> * types

Representation of k -> * types

Representation of unlifted types

Generic representation types

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Unboxed representation types

Instances

Synonyms for convenience

Meta-information

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Instances

Generic type classes

Instances

Instances

Individual fields of constructors: `K1`

Meta information: `M1`

Empty datatypes: `V1`

Constructors without fields: `U1`

The `Generic1` class

Representation of `* -> *` types

Representation of `k -> *` types