    {-# OPTIONS_GHC -Wno-noncanonical-monoid-instances #-}

    {-# LANGUAGE CPP                        #-}
    {-# LANGUAGE DataKinds                  #-}
    {-# LANGUAGE DeriveFunctor              #-}
    {-# LANGUAGE DeriveGeneric              #-}
    {-# LANGUAGE EmptyDataDeriving          #-}
    {-# LANGUAGE FlexibleContexts           #-}
    {-# LANGUAGE FlexibleInstances          #-}
    {-# LANGUAGE GADTs                      #-}
    {-# LANGUAGE GeneralizedNewtypeDeriving #-}
    {-# LANGUAGE InstanceSigs               #-}
    {-# LANGUAGE MagicHash                  #-}
    {-# LANGUAGE NoImplicitPrelude          #-}
    {-# LANGUAGE PolyKinds                  #-}
    {-# LANGUAGE ScopedTypeVariables        #-}
    {-# LANGUAGE StandaloneDeriving         #-}
    {-# LANGUAGE StandaloneKindSignatures   #-}
    {-# LANGUAGE Trustworthy                #-}
    {-# LANGUAGE TypeApplications           #-}
    {-# LANGUAGE TypeFamilies               #-}
    {-# LANGUAGE TypeOperators              #-}
    {-# LANGUAGE UndecidableInstances       #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  GHC.Generics
    -- 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
    --
    -- @since 4.6.0.0
    --
    -- 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.

    module GHC.Generics  (
    -- * 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:
    --
    --    1. /Generic instances/ for the function, implementing it for most of the representation
    --       type constructors introduced above.
    --
    --    2. 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)
    -- @
    --
    #if 0
    -- /TODO:/ Add usage example?
    --
    #endif
    -- The generic default is being used. In the future, it will hopefully be
    -- possible to use @deriving Encode@ as well, but GHC does not yet support
    -- that syntax for this situation.
    --
    -- Having @Encode@ as a class has the advantage that we can define
    -- non-generic special cases, which is particularly useful for abstract
    -- datatypes that have no structural representation. For example, given
    -- a suitable integer encoding function @encodeInt@, we can define
    --
    -- @
    -- instance Encode Int where
    --   encode = encodeInt
    -- @

    -- *** 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).
    #if 0
    -- *** Using meta-information
    --
    -- |
    --
    -- TODO
    #endif
    -- ** 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 'Data.Functor.Functor',
    -- 'Data.Traversable.Traversable', or 'Data.Foldable.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.
    #if 0
    -- *** Limitations
    --
    -- |
    --
    -- /TODO/
    --
    -- /TODO:/ Also clear up confusion about 'Rec0' and 'Rec1' not really indicating recursion.
    --
    #endif
    -----------------------------------------------------------------------------

      -- * Generic representation types
        V1, U1(..), Par1(..), Rec1(..), K1(..), M1(..)
      , (:+:)(..), (:*:)(..), (:.:)(..)

      -- ** Unboxed representation types
      , URec(..)
      , type UAddr, type UChar, type UDouble
      , type UFloat, type UInt, type UWord

      -- ** Synonyms for convenience
      , Rec0, R
      , D1, C1, S1, D, C, S

      -- * Meta-information
      , Datatype(..), Constructor(..), Selector(..)
      , Fixity(..), FixityI(..), Associativity(..), prec
      , SourceUnpackedness(..), SourceStrictness(..), DecidedStrictness(..)
      , Meta(..)

      -- * Generic type classes
      , Generic(..)
      , Generic1(..)

      -- * Generic wrapper
      , Generically(..)
      , Generically1(..)
      ) where

    -- We use some base types
    import Data.Either     ( Either (..) )
    import Data.Maybe      ( Maybe(..), fromMaybe )
    import Data.Ord        ( Down(..) )
    import GHC.Num.Integer ( Integer, integerToInt )
    import GHC.Prim        ( Addr#, Char#, Double#, Float#, Int#, Word# )
    import GHC.Ptr         ( Ptr )
    import GHC.Types

    -- Needed for instances
    import GHC.Ix      ( Ix )
    import GHC.Base    ( Alternative(..), Applicative(..), Functor(..)
                       , Monad(..), MonadPlus(..), NonEmpty(..), String, coerce
                       , Semigroup(..), Monoid(..), Void )
    import GHC.Classes ( Eq(..), Ord(..) )
    import GHC.Enum    ( Bounded, Enum )
    import GHC.Read    ( Read(..) )
    import GHC.Show    ( Show(..), showString )
    import GHC.Stack.Types ( SrcLoc(..) )
    import GHC.Tuple   (Solo (..))
    import GHC.Unicode ( GeneralCategory(..) )
    import GHC.Fingerprint.Type ( Fingerprint(..) )

    -- Needed for metadata
    import Data.Proxy   ( Proxy(..) )
    import GHC.TypeLits ( KnownSymbol, KnownNat, Nat, symbolVal, natVal )

    --------------------------------------------------------------------------------
    -- Representation types
    --------------------------------------------------------------------------------

    -- | Void: used for datatypes without constructors
    data V1 (p :: k)
      deriving ( V1 p -> V1 p -> Bool
    (V1 p -> V1 p -> Bool) -> (V1 p -> V1 p -> Bool) -> Eq (V1 p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (p :: k). V1 p -> V1 p -> Bool
    $c== :: forall k (p :: k). V1 p -> V1 p -> Bool
    == :: V1 p -> V1 p -> Bool
    $c/= :: forall k (p :: k). V1 p -> V1 p -> Bool
    /= :: V1 p -> V1 p -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (V1 p)
    Eq (V1 p) =>
    (V1 p -> V1 p -> Ordering)
    -> (V1 p -> V1 p -> Bool)
    -> (V1 p -> V1 p -> Bool)
    -> (V1 p -> V1 p -> Bool)
    -> (V1 p -> V1 p -> Bool)
    -> (V1 p -> V1 p -> V1 p)
    -> (V1 p -> V1 p -> V1 p)
    -> Ord (V1 p)
    V1 p -> V1 p -> Bool
    V1 p -> V1 p -> Ordering
    V1 p -> V1 p -> V1 p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (p :: k). Eq (V1 p)
    forall k (p :: k). V1 p -> V1 p -> Bool
    forall k (p :: k). V1 p -> V1 p -> Ordering
    forall k (p :: k). V1 p -> V1 p -> V1 p
    $ccompare :: forall k (p :: k). V1 p -> V1 p -> Ordering
    compare :: V1 p -> V1 p -> Ordering
    $c< :: forall k (p :: k). V1 p -> V1 p -> Bool
    < :: V1 p -> V1 p -> Bool
    $c<= :: forall k (p :: k). V1 p -> V1 p -> Bool
    <= :: V1 p -> V1 p -> Bool
    $c> :: forall k (p :: k). V1 p -> V1 p -> Bool
    > :: V1 p -> V1 p -> Bool
    $c>= :: forall k (p :: k). V1 p -> V1 p -> Bool
    >= :: V1 p -> V1 p -> Bool
    $cmax :: forall k (p :: k). V1 p -> V1 p -> V1 p
    max :: V1 p -> V1 p -> V1 p
    $cmin :: forall k (p :: k). V1 p -> V1 p -> V1 p
    min :: V1 p -> V1 p -> V1 p
    Ord      -- ^ @since 4.9.0.0
               , ReadPrec [V1 p]
    ReadPrec (V1 p)
    Int -> ReadS (V1 p)
    ReadS [V1 p]
    (Int -> ReadS (V1 p))
    -> ReadS [V1 p]
    -> ReadPrec (V1 p)
    -> ReadPrec [V1 p]
    -> Read (V1 p)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall k (p :: k). ReadPrec [V1 p]
    forall k (p :: k). ReadPrec (V1 p)
    forall k (p :: k). Int -> ReadS (V1 p)
    forall k (p :: k). ReadS [V1 p]
    $creadsPrec :: forall k (p :: k). Int -> ReadS (V1 p)
    readsPrec :: Int -> ReadS (V1 p)
    $creadList :: forall k (p :: k). ReadS [V1 p]
    readList :: ReadS [V1 p]
    $creadPrec :: forall k (p :: k). ReadPrec (V1 p)
    readPrec :: ReadPrec (V1 p)
    $creadListPrec :: forall k (p :: k). ReadPrec [V1 p]
    readListPrec :: ReadPrec [V1 p]
    Read     -- ^ @since 4.9.0.0
               , Int -> V1 p -> ShowS
    [V1 p] -> ShowS
    V1 p -> String
    (Int -> V1 p -> ShowS)
    -> (V1 p -> String) -> ([V1 p] -> ShowS) -> Show (V1 p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (p :: k). Int -> V1 p -> ShowS
    forall k (p :: k). [V1 p] -> ShowS
    forall k (p :: k). V1 p -> String
    $cshowsPrec :: forall k (p :: k). Int -> V1 p -> ShowS
    showsPrec :: Int -> V1 p -> ShowS
    $cshow :: forall k (p :: k). V1 p -> String
    show :: V1 p -> String
    $cshowList :: forall k (p :: k). [V1 p] -> ShowS
    showList :: [V1 p] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , (forall a b. (a -> b) -> V1 a -> V1 b)
    -> (forall a b. a -> V1 b -> V1 a) -> Functor V1
    forall a b. a -> V1 b -> V1 a
    forall a b. (a -> b) -> V1 a -> V1 b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> V1 a -> V1 b
    fmap :: forall a b. (a -> b) -> V1 a -> V1 b
    $c<$ :: forall a b. a -> V1 b -> V1 a
    <$ :: forall a b. a -> V1 b -> V1 a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. V1 p -> Rep (V1 p) x)
    -> (forall x. Rep (V1 p) x -> V1 p) -> Generic (V1 p)
    forall x. V1 p -> Rep (V1 p) x
    forall x. Rep (V1 p) x -> V1 p
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (p :: k) x. V1 p -> Rep (V1 p) x
    forall k (p :: k) x. Rep (V1 p) x -> V1 p
    $cfrom :: forall k (p :: k) x. V1 p -> Rep (V1 p) x
    from :: forall x. V1 p -> Rep (V1 p) x
    $cto :: forall k (p :: k) x. Rep (V1 p) x -> V1 p
    to :: forall x. Rep (V1 p) x -> V1 p
    Generic  -- ^ @since 4.9.0.0
               , (forall (a :: k). V1 a -> Rep1 V1 a)
    -> (forall (a :: k). Rep1 V1 a -> V1 a) -> Generic1 V1
    forall (a :: k). V1 a -> Rep1 V1 a
    forall (a :: k). Rep1 V1 a -> V1 a
    forall k (a :: k). V1 a -> Rep1 V1 a
    forall k (a :: k). Rep1 V1 a -> V1 a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k (a :: k). V1 a -> Rep1 V1 a
    from1 :: forall (a :: k). V1 a -> Rep1 V1 a
    $cto1 :: forall k (a :: k). Rep1 V1 a -> V1 a
    to1 :: forall (a :: k). Rep1 V1 a -> V1 a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.12.0.0
    instance Semigroup (V1 p) where
      V1 p
    v <> :: V1 p -> V1 p -> V1 p
    <> V1 p
    _ = V1 p
    v

    -- | Unit: used for constructors without arguments
    data U1 (p :: k) = U1
      deriving ( (forall x. U1 p -> Rep (U1 p) x)
    -> (forall x. Rep (U1 p) x -> U1 p) -> Generic (U1 p)
    forall x. U1 p -> Rep (U1 p) x
    forall x. Rep (U1 p) x -> U1 p
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (p :: k) x. U1 p -> Rep (U1 p) x
    forall k (p :: k) x. Rep (U1 p) x -> U1 p
    $cfrom :: forall k (p :: k) x. U1 p -> Rep (U1 p) x
    from :: forall x. U1 p -> Rep (U1 p) x
    $cto :: forall k (p :: k) x. Rep (U1 p) x -> U1 p
    to :: forall x. Rep (U1 p) x -> U1 p
    Generic  -- ^ @since 4.7.0.0
               , (forall (a :: k). U1 a -> Rep1 U1 a)
    -> (forall (a :: k). Rep1 U1 a -> U1 a) -> Generic1 U1
    forall (a :: k). U1 a -> Rep1 U1 a
    forall (a :: k). Rep1 U1 a -> U1 a
    forall k (a :: k). U1 a -> Rep1 U1 a
    forall k (a :: k). Rep1 U1 a -> U1 a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k (a :: k). U1 a -> Rep1 U1 a
    from1 :: forall (a :: k). U1 a -> Rep1 U1 a
    $cto1 :: forall k (a :: k). Rep1 U1 a -> U1 a
    to1 :: forall (a :: k). Rep1 U1 a -> U1 a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    instance Eq (U1 p) where
      U1 p
    _ == :: U1 p -> U1 p -> Bool
    == U1 p
    _ = Bool
    True

    -- | @since 4.7.0.0
    instance Ord (U1 p) where
      compare :: U1 p -> U1 p -> Ordering
    compare U1 p
    _ U1 p
    _ = Ordering
    EQ

    -- | @since 4.9.0.0
    deriving instance Read (U1 p)

    -- | @since 4.9.0.0
    instance Show (U1 p) where
      showsPrec :: Int -> U1 p -> ShowS
    showsPrec Int
    _ U1 p
    _ = String -> ShowS
    showString String
    "U1"

    -- | @since 4.9.0.0
    instance Functor U1 where
      fmap :: forall a b. (a -> b) -> U1 a -> U1 b
    fmap a -> b
    _ U1 a
    _ = U1 b
    forall k (p :: k). U1 p
    U1

    -- | @since 4.9.0.0
    instance Applicative U1 where
      pure :: forall a. a -> U1 a
    pure a
    _ = U1 a
    forall k (p :: k). U1 p
    U1
      U1 (a -> b)
    _ <*> :: forall a b. U1 (a -> b) -> U1 a -> U1 b
    <*> U1 a
    _ = U1 b
    forall k (p :: k). U1 p
    U1
      liftA2 :: forall a b c. (a -> b -> c) -> U1 a -> U1 b -> U1 c
    liftA2 a -> b -> c
    _ U1 a
    _ U1 b
    _ = U1 c
    forall k (p :: k). U1 p
    U1

    -- | @since 4.9.0.0
    instance Alternative U1 where
      empty :: forall a. U1 a
    empty = U1 a
    forall k (p :: k). U1 p
    U1
      U1 a
    _ <|> :: forall a. U1 a -> U1 a -> U1 a
    <|> U1 a
    _ = U1 a
    forall k (p :: k). U1 p
    U1

    -- | @since 4.9.0.0
    instance Monad U1 where
      U1 a
    _ >>= :: forall a b. U1 a -> (a -> U1 b) -> U1 b
    >>= a -> U1 b
    _ = U1 b
    forall k (p :: k). U1 p
    U1

    -- | @since 4.9.0.0
    instance MonadPlus U1

    -- | @since 4.12.0.0
    instance Semigroup (U1 p) where
      U1 p
    _ <> :: U1 p -> U1 p -> U1 p
    <> U1 p
    _ = U1 p
    forall k (p :: k). U1 p
    U1

    -- | @since 4.12.0.0
    instance Monoid (U1 p) where
      mempty :: U1 p
    mempty = U1 p
    forall k (p :: k). U1 p
    U1

    -- | Used for marking occurrences of the parameter
    newtype Par1 p = Par1 { forall p. Par1 p -> p
    unPar1 :: p }
      deriving ( Par1 p -> Par1 p -> Bool
    (Par1 p -> Par1 p -> Bool)
    -> (Par1 p -> Par1 p -> Bool) -> Eq (Par1 p)
    forall p. Eq p => Par1 p -> Par1 p -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall p. Eq p => Par1 p -> Par1 p -> Bool
    == :: Par1 p -> Par1 p -> Bool
    $c/= :: forall p. Eq p => Par1 p -> Par1 p -> Bool
    /= :: Par1 p -> Par1 p -> Bool
    Eq       -- ^ @since 4.7.0.0
               , Eq (Par1 p)
    Eq (Par1 p) =>
    (Par1 p -> Par1 p -> Ordering)
    -> (Par1 p -> Par1 p -> Bool)
    -> (Par1 p -> Par1 p -> Bool)
    -> (Par1 p -> Par1 p -> Bool)
    -> (Par1 p -> Par1 p -> Bool)
    -> (Par1 p -> Par1 p -> Par1 p)
    -> (Par1 p -> Par1 p -> Par1 p)
    -> Ord (Par1 p)
    Par1 p -> Par1 p -> Bool
    Par1 p -> Par1 p -> Ordering
    Par1 p -> Par1 p -> Par1 p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall p. Ord p => Eq (Par1 p)
    forall p. Ord p => Par1 p -> Par1 p -> Bool
    forall p. Ord p => Par1 p -> Par1 p -> Ordering
    forall p. Ord p => Par1 p -> Par1 p -> Par1 p
    $ccompare :: forall p. Ord p => Par1 p -> Par1 p -> Ordering
    compare :: Par1 p -> Par1 p -> Ordering
    $c< :: forall p. Ord p => Par1 p -> Par1 p -> Bool
    < :: Par1 p -> Par1 p -> Bool
    $c<= :: forall p. Ord p => Par1 p -> Par1 p -> Bool
    <= :: Par1 p -> Par1 p -> Bool
    $c> :: forall p. Ord p => Par1 p -> Par1 p -> Bool
    > :: Par1 p -> Par1 p -> Bool
    $c>= :: forall p. Ord p => Par1 p -> Par1 p -> Bool
    >= :: Par1 p -> Par1 p -> Bool
    $cmax :: forall p. Ord p => Par1 p -> Par1 p -> Par1 p
    max :: Par1 p -> Par1 p -> Par1 p
    $cmin :: forall p. Ord p => Par1 p -> Par1 p -> Par1 p
    min :: Par1 p -> Par1 p -> Par1 p
    Ord      -- ^ @since 4.7.0.0
               , ReadPrec [Par1 p]
    ReadPrec (Par1 p)
    Int -> ReadS (Par1 p)
    ReadS [Par1 p]
    (Int -> ReadS (Par1 p))
    -> ReadS [Par1 p]
    -> ReadPrec (Par1 p)
    -> ReadPrec [Par1 p]
    -> Read (Par1 p)
    forall p. Read p => ReadPrec [Par1 p]
    forall p. Read p => ReadPrec (Par1 p)
    forall p. Read p => Int -> ReadS (Par1 p)
    forall p. Read p => ReadS [Par1 p]
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: forall p. Read p => Int -> ReadS (Par1 p)
    readsPrec :: Int -> ReadS (Par1 p)
    $creadList :: forall p. Read p => ReadS [Par1 p]
    readList :: ReadS [Par1 p]
    $creadPrec :: forall p. Read p => ReadPrec (Par1 p)
    readPrec :: ReadPrec (Par1 p)
    $creadListPrec :: forall p. Read p => ReadPrec [Par1 p]
    readListPrec :: ReadPrec [Par1 p]
    Read     -- ^ @since 4.7.0.0
               , Int -> Par1 p -> ShowS
    [Par1 p] -> ShowS
    Par1 p -> String
    (Int -> Par1 p -> ShowS)
    -> (Par1 p -> String) -> ([Par1 p] -> ShowS) -> Show (Par1 p)
    forall p. Show p => Int -> Par1 p -> ShowS
    forall p. Show p => [Par1 p] -> ShowS
    forall p. Show p => Par1 p -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall p. Show p => Int -> Par1 p -> ShowS
    showsPrec :: Int -> Par1 p -> ShowS
    $cshow :: forall p. Show p => Par1 p -> String
    show :: Par1 p -> String
    $cshowList :: forall p. Show p => [Par1 p] -> ShowS
    showList :: [Par1 p] -> ShowS
    Show     -- ^ @since 4.7.0.0
               , (forall a b. (a -> b) -> Par1 a -> Par1 b)
    -> (forall a b. a -> Par1 b -> Par1 a) -> Functor Par1
    forall a b. a -> Par1 b -> Par1 a
    forall a b. (a -> b) -> Par1 a -> Par1 b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> Par1 a -> Par1 b
    fmap :: forall a b. (a -> b) -> Par1 a -> Par1 b
    $c<$ :: forall a b. a -> Par1 b -> Par1 a
    <$ :: forall a b. a -> Par1 b -> Par1 a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. Par1 p -> Rep (Par1 p) x)
    -> (forall x. Rep (Par1 p) x -> Par1 p) -> Generic (Par1 p)
    forall x. Par1 p -> Rep (Par1 p) x
    forall x. Rep (Par1 p) x -> Par1 p
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall p x. Par1 p -> Rep (Par1 p) x
    forall p x. Rep (Par1 p) x -> Par1 p
    $cfrom :: forall p x. Par1 p -> Rep (Par1 p) x
    from :: forall x. Par1 p -> Rep (Par1 p) x
    $cto :: forall p x. Rep (Par1 p) x -> Par1 p
    to :: forall x. Rep (Par1 p) x -> Par1 p
    Generic  -- ^ @since 4.7.0.0
               , (forall a. Par1 a -> Rep1 Par1 a)
    -> (forall a. Rep1 Par1 a -> Par1 a) -> Generic1 Par1
    forall a. Par1 a -> Rep1 Par1 a
    forall a. Rep1 Par1 a -> Par1 a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall a. Par1 a -> Rep1 Par1 a
    from1 :: forall a. Par1 a -> Rep1 Par1 a
    $cto1 :: forall a. Rep1 Par1 a -> Par1 a
    to1 :: forall a. Rep1 Par1 a -> Par1 a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    instance Applicative Par1 where
      pure :: forall a. a -> Par1 a
    pure = a -> Par1 a
    forall a. a -> Par1 a
    Par1
      <*> :: forall a b. Par1 (a -> b) -> Par1 a -> Par1 b
    (<*>) = Par1 (a -> b) -> Par1 a -> Par1 b
    forall a b. Coercible a b => a -> b
    coerce
      liftA2 :: forall a b c. (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c
    liftA2 = (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c
    forall a b. Coercible a b => a -> b
    coerce

    -- | @since 4.9.0.0
    instance Monad Par1 where
      Par1 a
    x >>= :: forall a b. Par1 a -> (a -> Par1 b) -> Par1 b
    >>= a -> Par1 b
    f = a -> Par1 b
    f a
    x

    -- | @since 4.12.0.0
    deriving instance Semigroup p => Semigroup (Par1 p)

    -- | @since 4.12.0.0
    deriving instance Monoid p => Monoid (Par1 p)

    -- | Recursive calls of kind @* -> *@ (or kind @k -> *@, when @PolyKinds@
    -- is enabled)
    newtype Rec1 (f :: k -> Type) (p :: k) = Rec1 { forall k (f :: k -> *) (p :: k). Rec1 f p -> f p
    unRec1 :: f p }
      deriving ( Rec1 f p -> Rec1 f p -> Bool
    (Rec1 f p -> Rec1 f p -> Bool)
    -> (Rec1 f p -> Rec1 f p -> Bool) -> Eq (Rec1 f p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (f :: k -> *) (p :: k).
    Eq (f p) =>
    Rec1 f p -> Rec1 f p -> Bool
    $c== :: forall k (f :: k -> *) (p :: k).
    Eq (f p) =>
    Rec1 f p -> Rec1 f p -> Bool
    == :: Rec1 f p -> Rec1 f p -> Bool
    $c/= :: forall k (f :: k -> *) (p :: k).
    Eq (f p) =>
    Rec1 f p -> Rec1 f p -> Bool
    /= :: Rec1 f p -> Rec1 f p -> Bool
    Eq       -- ^ @since 4.7.0.0
               , Eq (Rec1 f p)
    Eq (Rec1 f p) =>
    (Rec1 f p -> Rec1 f p -> Ordering)
    -> (Rec1 f p -> Rec1 f p -> Bool)
    -> (Rec1 f p -> Rec1 f p -> Bool)
    -> (Rec1 f p -> Rec1 f p -> Bool)
    -> (Rec1 f p -> Rec1 f p -> Bool)
    -> (Rec1 f p -> Rec1 f p -> Rec1 f p)
    -> (Rec1 f p -> Rec1 f p -> Rec1 f p)
    -> Ord (Rec1 f p)
    Rec1 f p -> Rec1 f p -> Bool
    Rec1 f p -> Rec1 f p -> Ordering
    Rec1 f p -> Rec1 f p -> Rec1 f p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (f :: k -> *) (p :: k). Ord (f p) => Eq (Rec1 f p)
    forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Bool
    forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Ordering
    forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Rec1 f p
    $ccompare :: forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Ordering
    compare :: Rec1 f p -> Rec1 f p -> Ordering
    $c< :: forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Bool
    < :: Rec1 f p -> Rec1 f p -> Bool
    $c<= :: forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Bool
    <= :: Rec1 f p -> Rec1 f p -> Bool
    $c> :: forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Bool
    > :: Rec1 f p -> Rec1 f p -> Bool
    $c>= :: forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Bool
    >= :: Rec1 f p -> Rec1 f p -> Bool
    $cmax :: forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Rec1 f p
    max :: Rec1 f p -> Rec1 f p -> Rec1 f p
    $cmin :: forall k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Rec1 f p -> Rec1 f p -> Rec1 f p
    min :: Rec1 f p -> Rec1 f p -> Rec1 f p
    Ord      -- ^ @since 4.7.0.0
               , ReadPrec [Rec1 f p]
    ReadPrec (Rec1 f p)
    Int -> ReadS (Rec1 f p)
    ReadS [Rec1 f p]
    (Int -> ReadS (Rec1 f p))
    -> ReadS [Rec1 f p]
    -> ReadPrec (Rec1 f p)
    -> ReadPrec [Rec1 f p]
    -> Read (Rec1 f p)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall k (f :: k -> *) (p :: k). Read (f p) => ReadPrec [Rec1 f p]
    forall k (f :: k -> *) (p :: k). Read (f p) => ReadPrec (Rec1 f p)
    forall k (f :: k -> *) (p :: k).
    Read (f p) =>
    Int -> ReadS (Rec1 f p)
    forall k (f :: k -> *) (p :: k). Read (f p) => ReadS [Rec1 f p]
    $creadsPrec :: forall k (f :: k -> *) (p :: k).
    Read (f p) =>
    Int -> ReadS (Rec1 f p)
    readsPrec :: Int -> ReadS (Rec1 f p)
    $creadList :: forall k (f :: k -> *) (p :: k). Read (f p) => ReadS [Rec1 f p]
    readList :: ReadS [Rec1 f p]
    $creadPrec :: forall k (f :: k -> *) (p :: k). Read (f p) => ReadPrec (Rec1 f p)
    readPrec :: ReadPrec (Rec1 f p)
    $creadListPrec :: forall k (f :: k -> *) (p :: k). Read (f p) => ReadPrec [Rec1 f p]
    readListPrec :: ReadPrec [Rec1 f p]
    Read     -- ^ @since 4.7.0.0
               , Int -> Rec1 f p -> ShowS
    [Rec1 f p] -> ShowS
    Rec1 f p -> String
    (Int -> Rec1 f p -> ShowS)
    -> (Rec1 f p -> String) -> ([Rec1 f p] -> ShowS) -> Show (Rec1 f p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (f :: k -> *) (p :: k).
    Show (f p) =>
    Int -> Rec1 f p -> ShowS
    forall k (f :: k -> *) (p :: k). Show (f p) => [Rec1 f p] -> ShowS
    forall k (f :: k -> *) (p :: k). Show (f p) => Rec1 f p -> String
    $cshowsPrec :: forall k (f :: k -> *) (p :: k).
    Show (f p) =>
    Int -> Rec1 f p -> ShowS
    showsPrec :: Int -> Rec1 f p -> ShowS
    $cshow :: forall k (f :: k -> *) (p :: k). Show (f p) => Rec1 f p -> String
    show :: Rec1 f p -> String
    $cshowList :: forall k (f :: k -> *) (p :: k). Show (f p) => [Rec1 f p] -> ShowS
    showList :: [Rec1 f p] -> ShowS
    Show     -- ^ @since 4.7.0.0
               , (forall a b. (a -> b) -> Rec1 f a -> Rec1 f b)
    -> (forall a b. a -> Rec1 f b -> Rec1 f a) -> Functor (Rec1 f)
    forall a b. a -> Rec1 f b -> Rec1 f a
    forall a b. (a -> b) -> Rec1 f a -> Rec1 f b
    forall (f :: * -> *) a b. Functor f => a -> Rec1 f b -> Rec1 f a
    forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> Rec1 f a -> Rec1 f b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> Rec1 f a -> Rec1 f b
    fmap :: forall a b. (a -> b) -> Rec1 f a -> Rec1 f b
    $c<$ :: forall (f :: * -> *) a b. Functor f => a -> Rec1 f b -> Rec1 f a
    <$ :: forall a b. a -> Rec1 f b -> Rec1 f a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. Rec1 f p -> Rep (Rec1 f p) x)
    -> (forall x. Rep (Rec1 f p) x -> Rec1 f p) -> Generic (Rec1 f p)
    forall x. Rec1 f p -> Rep (Rec1 f p) x
    forall x. Rep (Rec1 f p) x -> Rec1 f p
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (f :: k -> *) (p :: k) x. Rec1 f p -> Rep (Rec1 f p) x
    forall k (f :: k -> *) (p :: k) x. Rep (Rec1 f p) x -> Rec1 f p
    $cfrom :: forall k (f :: k -> *) (p :: k) x. Rec1 f p -> Rep (Rec1 f p) x
    from :: forall x. Rec1 f p -> Rep (Rec1 f p) x
    $cto :: forall k (f :: k -> *) (p :: k) x. Rep (Rec1 f p) x -> Rec1 f p
    to :: forall x. Rep (Rec1 f p) x -> Rec1 f p
    Generic  -- ^ @since 4.7.0.0
               , (forall (a :: k). Rec1 f a -> Rep1 (Rec1 f) a)
    -> (forall (a :: k). Rep1 (Rec1 f) a -> Rec1 f a)
    -> Generic1 (Rec1 f)
    forall (a :: k). Rec1 f a -> Rep1 (Rec1 f) a
    forall (a :: k). Rep1 (Rec1 f) a -> Rec1 f a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    forall k (f :: k -> *) (a :: k). Rec1 f a -> Rep1 (Rec1 f) a
    forall k (f :: k -> *) (a :: k). Rep1 (Rec1 f) a -> Rec1 f a
    $cfrom1 :: forall k (f :: k -> *) (a :: k). Rec1 f a -> Rep1 (Rec1 f) a
    from1 :: forall (a :: k). Rec1 f a -> Rep1 (Rec1 f) a
    $cto1 :: forall k (f :: k -> *) (a :: k). Rep1 (Rec1 f) a -> Rec1 f a
    to1 :: forall (a :: k). Rep1 (Rec1 f) a -> Rec1 f a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    deriving instance Applicative f => Applicative (Rec1 f)

    -- | @since 4.9.0.0
    deriving instance Alternative f => Alternative (Rec1 f)

    -- | @since 4.9.0.0
    instance Monad f => Monad (Rec1 f) where
      Rec1 f a
    x >>= :: forall a b. Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b
    >>= a -> Rec1 f b
    f = f b -> Rec1 f b
    forall k (f :: k -> *) (p :: k). f p -> Rec1 f p
    Rec1 (f a
    x f a -> (a -> f b) -> f b
    forall a b. f a -> (a -> f b) -> f b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \a
    a -> Rec1 f b -> f b
    forall k (f :: k -> *) (p :: k). Rec1 f p -> f p
    unRec1 (a -> Rec1 f b
    f a
    a))

    -- | @since 4.9.0.0
    deriving instance MonadPlus f => MonadPlus (Rec1 f)

    -- | @since 4.12.0.0
    deriving instance Semigroup (f p) => Semigroup (Rec1 f p)

    -- | @since 4.12.0.0
    deriving instance Monoid (f p) => Monoid (Rec1 f p)

    -- | Constants, additional parameters and recursion of kind @*@
    newtype K1 (i :: Type) c (p :: k) = K1 { forall k i c (p :: k). K1 i c p -> c
    unK1 :: c }
      deriving ( K1 i c p -> K1 i c p -> Bool
    (K1 i c p -> K1 i c p -> Bool)
    -> (K1 i c p -> K1 i c p -> Bool) -> Eq (K1 i c p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall i c k (p :: k). Eq c => K1 i c p -> K1 i c p -> Bool
    $c== :: forall i c k (p :: k). Eq c => K1 i c p -> K1 i c p -> Bool
    == :: K1 i c p -> K1 i c p -> Bool
    $c/= :: forall i c k (p :: k). Eq c => K1 i c p -> K1 i c p -> Bool
    /= :: K1 i c p -> K1 i c p -> Bool
    Eq       -- ^ @since 4.7.0.0
               , Eq (K1 i c p)
    Eq (K1 i c p) =>
    (K1 i c p -> K1 i c p -> Ordering)
    -> (K1 i c p -> K1 i c p -> Bool)
    -> (K1 i c p -> K1 i c p -> Bool)
    -> (K1 i c p -> K1 i c p -> Bool)
    -> (K1 i c p -> K1 i c p -> Bool)
    -> (K1 i c p -> K1 i c p -> K1 i c p)
    -> (K1 i c p -> K1 i c p -> K1 i c p)
    -> Ord (K1 i c p)
    K1 i c p -> K1 i c p -> Bool
    K1 i c p -> K1 i c p -> Ordering
    K1 i c p -> K1 i c p -> K1 i c p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall i c k (p :: k). Ord c => Eq (K1 i c p)
    forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> Bool
    forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> Ordering
    forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> K1 i c p
    $ccompare :: forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> Ordering
    compare :: K1 i c p -> K1 i c p -> Ordering
    $c< :: forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> Bool
    < :: K1 i c p -> K1 i c p -> Bool
    $c<= :: forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> Bool
    <= :: K1 i c p -> K1 i c p -> Bool
    $c> :: forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> Bool
    > :: K1 i c p -> K1 i c p -> Bool
    $c>= :: forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> Bool
    >= :: K1 i c p -> K1 i c p -> Bool
    $cmax :: forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> K1 i c p
    max :: K1 i c p -> K1 i c p -> K1 i c p
    $cmin :: forall i c k (p :: k). Ord c => K1 i c p -> K1 i c p -> K1 i c p
    min :: K1 i c p -> K1 i c p -> K1 i c p
    Ord      -- ^ @since 4.7.0.0
               , ReadPrec [K1 i c p]
    ReadPrec (K1 i c p)
    Int -> ReadS (K1 i c p)
    ReadS [K1 i c p]
    (Int -> ReadS (K1 i c p))
    -> ReadS [K1 i c p]
    -> ReadPrec (K1 i c p)
    -> ReadPrec [K1 i c p]
    -> Read (K1 i c p)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall i c k (p :: k). Read c => ReadPrec [K1 i c p]
    forall i c k (p :: k). Read c => ReadPrec (K1 i c p)
    forall i c k (p :: k). Read c => Int -> ReadS (K1 i c p)
    forall i c k (p :: k). Read c => ReadS [K1 i c p]
    $creadsPrec :: forall i c k (p :: k). Read c => Int -> ReadS (K1 i c p)
    readsPrec :: Int -> ReadS (K1 i c p)
    $creadList :: forall i c k (p :: k). Read c => ReadS [K1 i c p]
    readList :: ReadS [K1 i c p]
    $creadPrec :: forall i c k (p :: k). Read c => ReadPrec (K1 i c p)
    readPrec :: ReadPrec (K1 i c p)
    $creadListPrec :: forall i c k (p :: k). Read c => ReadPrec [K1 i c p]
    readListPrec :: ReadPrec [K1 i c p]
    Read     -- ^ @since 4.7.0.0
               , Int -> K1 i c p -> ShowS
    [K1 i c p] -> ShowS
    K1 i c p -> String
    (Int -> K1 i c p -> ShowS)
    -> (K1 i c p -> String) -> ([K1 i c p] -> ShowS) -> Show (K1 i c p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall i c k (p :: k). Show c => Int -> K1 i c p -> ShowS
    forall i c k (p :: k). Show c => [K1 i c p] -> ShowS
    forall i c k (p :: k). Show c => K1 i c p -> String
    $cshowsPrec :: forall i c k (p :: k). Show c => Int -> K1 i c p -> ShowS
    showsPrec :: Int -> K1 i c p -> ShowS
    $cshow :: forall i c k (p :: k). Show c => K1 i c p -> String
    show :: K1 i c p -> String
    $cshowList :: forall i c k (p :: k). Show c => [K1 i c p] -> ShowS
    showList :: [K1 i c p] -> ShowS
    Show     -- ^ @since 4.7.0.0
               , (forall a b. (a -> b) -> K1 i c a -> K1 i c b)
    -> (forall a b. a -> K1 i c b -> K1 i c a) -> Functor (K1 i c)
    forall a b. a -> K1 i c b -> K1 i c a
    forall a b. (a -> b) -> K1 i c a -> K1 i c b
    forall i c a b. a -> K1 i c b -> K1 i c a
    forall i c a b. (a -> b) -> K1 i c a -> K1 i c b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall i c a b. (a -> b) -> K1 i c a -> K1 i c b
    fmap :: forall a b. (a -> b) -> K1 i c a -> K1 i c b
    $c<$ :: forall i c a b. a -> K1 i c b -> K1 i c a
    <$ :: forall a b. a -> K1 i c b -> K1 i c a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. K1 i c p -> Rep (K1 i c p) x)
    -> (forall x. Rep (K1 i c p) x -> K1 i c p) -> Generic (K1 i c p)
    forall x. K1 i c p -> Rep (K1 i c p) x
    forall x. Rep (K1 i c p) x -> K1 i c p
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall i c k (p :: k) x. K1 i c p -> Rep (K1 i c p) x
    forall i c k (p :: k) x. Rep (K1 i c p) x -> K1 i c p
    $cfrom :: forall i c k (p :: k) x. K1 i c p -> Rep (K1 i c p) x
    from :: forall x. K1 i c p -> Rep (K1 i c p) x
    $cto :: forall i c k (p :: k) x. Rep (K1 i c p) x -> K1 i c p
    to :: forall x. Rep (K1 i c p) x -> K1 i c p
    Generic  -- ^ @since 4.7.0.0
               , (forall (a :: k). K1 i c a -> Rep1 (K1 i c) a)
    -> (forall (a :: k). Rep1 (K1 i c) a -> K1 i c a)
    -> Generic1 (K1 i c)
    forall (a :: k). K1 i c a -> Rep1 (K1 i c) a
    forall (a :: k). Rep1 (K1 i c) a -> K1 i c a
    forall k i c (a :: k). K1 i c a -> Rep1 (K1 i c) a
    forall k i c (a :: k). Rep1 (K1 i c) a -> K1 i c a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k i c (a :: k). K1 i c a -> Rep1 (K1 i c) a
    from1 :: forall (a :: k). K1 i c a -> Rep1 (K1 i c) a
    $cto1 :: forall k i c (a :: k). Rep1 (K1 i c) a -> K1 i c a
    to1 :: forall (a :: k). Rep1 (K1 i c) a -> K1 i c a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.12.0.0
    instance Monoid c => Applicative (K1 i c) where
      pure :: forall a. a -> K1 i c a
    pure a
    _ = c -> K1 i c a
    forall k i c (p :: k). c -> K1 i c p
    K1 c
    forall a. Monoid a => a
    mempty
      liftA2 :: forall a b c. (a -> b -> c) -> K1 i c a -> K1 i c b -> K1 i c c
    liftA2 = \a -> b -> c
    _ -> (c -> c -> c) -> K1 i c a -> K1 i c b -> K1 i c c
    forall a b. Coercible a b => a -> b
    coerce (c -> c -> c
    forall a. Monoid a => a -> a -> a
    mappend :: c -> c -> c)
      <*> :: forall a b. K1 i c (a -> b) -> K1 i c a -> K1 i c b
    (<*>) = (c -> c -> c) -> K1 i c (a -> b) -> K1 i c a -> K1 i c b
    forall a b. Coercible a b => a -> b
    coerce (c -> c -> c
    forall a. Monoid a => a -> a -> a
    mappend :: c -> c -> c)

    -- | @since 4.12.0.0
    deriving instance Semigroup c => Semigroup (K1 i c p)

    -- | @since 4.12.0.0
    deriving instance Monoid c => Monoid (K1 i c p)

    -- | @since 4.9.0.0
    deriving instance Applicative f => Applicative (M1 i c f)

    -- | @since 4.9.0.0
    deriving instance Alternative f => Alternative (M1 i c f)

    -- | @since 4.9.0.0
    deriving instance Monad f => Monad (M1 i c f)

    -- | @since 4.9.0.0
    deriving instance MonadPlus f => MonadPlus (M1 i c f)

    -- | @since 4.12.0.0
    deriving instance Semigroup (f p) => Semigroup (M1 i c f p)

    -- | @since 4.12.0.0
    deriving instance Monoid (f p) => Monoid (M1 i c f p)

    -- | Meta-information (constructor names, etc.)
    newtype M1 (i :: Type) (c :: Meta) (f :: k -> Type) (p :: k) =
        M1 { forall k i (c :: Meta) (f :: k -> *) (p :: k). M1 i c f p -> f p
    unM1 :: f p }
      deriving ( M1 i c f p -> M1 i c f p -> Bool
    (M1 i c f p -> M1 i c f p -> Bool)
    -> (M1 i c f p -> M1 i c f p -> Bool) -> Eq (M1 i c f p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Eq (f p) =>
    M1 i c f p -> M1 i c f p -> Bool
    $c== :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Eq (f p) =>
    M1 i c f p -> M1 i c f p -> Bool
    == :: M1 i c f p -> M1 i c f p -> Bool
    $c/= :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Eq (f p) =>
    M1 i c f p -> M1 i c f p -> Bool
    /= :: M1 i c f p -> M1 i c f p -> Bool
    Eq       -- ^ @since 4.7.0.0
               , Eq (M1 i c f p)
    Eq (M1 i c f p) =>
    (M1 i c f p -> M1 i c f p -> Ordering)
    -> (M1 i c f p -> M1 i c f p -> Bool)
    -> (M1 i c f p -> M1 i c f p -> Bool)
    -> (M1 i c f p -> M1 i c f p -> Bool)
    -> (M1 i c f p -> M1 i c f p -> Bool)
    -> (M1 i c f p -> M1 i c f p -> M1 i c f p)
    -> (M1 i c f p -> M1 i c f p -> M1 i c f p)
    -> Ord (M1 i c f p)
    M1 i c f p -> M1 i c f p -> Bool
    M1 i c f p -> M1 i c f p -> Ordering
    M1 i c f p -> M1 i c f p -> M1 i c f p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    Eq (M1 i c f p)
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> Bool
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> Ordering
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> M1 i c f p
    $ccompare :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> Ordering
    compare :: M1 i c f p -> M1 i c f p -> Ordering
    $c< :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> Bool
    < :: M1 i c f p -> M1 i c f p -> Bool
    $c<= :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> Bool
    <= :: M1 i c f p -> M1 i c f p -> Bool
    $c> :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> Bool
    > :: M1 i c f p -> M1 i c f p -> Bool
    $c>= :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> Bool
    >= :: M1 i c f p -> M1 i c f p -> Bool
    $cmax :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> M1 i c f p
    max :: M1 i c f p -> M1 i c f p -> M1 i c f p
    $cmin :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Ord (f p) =>
    M1 i c f p -> M1 i c f p -> M1 i c f p
    min :: M1 i c f p -> M1 i c f p -> M1 i c f p
    Ord      -- ^ @since 4.7.0.0
               , ReadPrec [M1 i c f p]
    ReadPrec (M1 i c f p)
    Int -> ReadS (M1 i c f p)
    ReadS [M1 i c f p]
    (Int -> ReadS (M1 i c f p))
    -> ReadS [M1 i c f p]
    -> ReadPrec (M1 i c f p)
    -> ReadPrec [M1 i c f p]
    -> Read (M1 i c f p)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Read (f p) =>
    ReadPrec [M1 i c f p]
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Read (f p) =>
    ReadPrec (M1 i c f p)
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Read (f p) =>
    Int -> ReadS (M1 i c f p)
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Read (f p) =>
    ReadS [M1 i c f p]
    $creadsPrec :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Read (f p) =>
    Int -> ReadS (M1 i c f p)
    readsPrec :: Int -> ReadS (M1 i c f p)
    $creadList :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Read (f p) =>
    ReadS [M1 i c f p]
    readList :: ReadS [M1 i c f p]
    $creadPrec :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Read (f p) =>
    ReadPrec (M1 i c f p)
    readPrec :: ReadPrec (M1 i c f p)
    $creadListPrec :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Read (f p) =>
    ReadPrec [M1 i c f p]
    readListPrec :: ReadPrec [M1 i c f p]
    Read     -- ^ @since 4.7.0.0
               , Int -> M1 i c f p -> ShowS
    [M1 i c f p] -> ShowS
    M1 i c f p -> String
    (Int -> M1 i c f p -> ShowS)
    -> (M1 i c f p -> String)
    -> ([M1 i c f p] -> ShowS)
    -> Show (M1 i c f p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Show (f p) =>
    Int -> M1 i c f p -> ShowS
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Show (f p) =>
    [M1 i c f p] -> ShowS
    forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Show (f p) =>
    M1 i c f p -> String
    $cshowsPrec :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Show (f p) =>
    Int -> M1 i c f p -> ShowS
    showsPrec :: Int -> M1 i c f p -> ShowS
    $cshow :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Show (f p) =>
    M1 i c f p -> String
    show :: M1 i c f p -> String
    $cshowList :: forall i (c :: Meta) k (f :: k -> *) (p :: k).
    Show (f p) =>
    [M1 i c f p] -> ShowS
    showList :: [M1 i c f p] -> ShowS
    Show     -- ^ @since 4.7.0.0
               , (forall a b. (a -> b) -> M1 i c f a -> M1 i c f b)
    -> (forall a b. a -> M1 i c f b -> M1 i c f a)
    -> Functor (M1 i c f)
    forall a b. a -> M1 i c f b -> M1 i c f a
    forall a b. (a -> b) -> M1 i c f a -> M1 i c f b
    forall i (c :: Meta) (f :: * -> *) a b.
    Functor f =>
    a -> M1 i c f b -> M1 i c f a
    forall i (c :: Meta) (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> M1 i c f a -> M1 i c f b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall i (c :: Meta) (f :: * -> *) a b.
    Functor f =>
    (a -> b) -> M1 i c f a -> M1 i c f b
    fmap :: forall a b. (a -> b) -> M1 i c f a -> M1 i c f b
    $c<$ :: forall i (c :: Meta) (f :: * -> *) a b.
    Functor f =>
    a -> M1 i c f b -> M1 i c f a
    <$ :: forall a b. a -> M1 i c f b -> M1 i c f a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. M1 i c f p -> Rep (M1 i c f p) x)
    -> (forall x. Rep (M1 i c f p) x -> M1 i c f p)
    -> Generic (M1 i c f p)
    forall x. M1 i c f p -> Rep (M1 i c f p) x
    forall x. Rep (M1 i c f p) x -> M1 i c f p
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall i (c :: Meta) k (f :: k -> *) (p :: k) x.
    M1 i c f p -> Rep (M1 i c f p) x
    forall i (c :: Meta) k (f :: k -> *) (p :: k) x.
    Rep (M1 i c f p) x -> M1 i c f p
    $cfrom :: forall i (c :: Meta) k (f :: k -> *) (p :: k) x.
    M1 i c f p -> Rep (M1 i c f p) x
    from :: forall x. M1 i c f p -> Rep (M1 i c f p) x
    $cto :: forall i (c :: Meta) k (f :: k -> *) (p :: k) x.
    Rep (M1 i c f p) x -> M1 i c f p
    to :: forall x. Rep (M1 i c f p) x -> M1 i c f p
    Generic  -- ^ @since 4.7.0.0
               , (forall (a :: k). M1 i c f a -> Rep1 (M1 i c f) a)
    -> (forall (a :: k). Rep1 (M1 i c f) a -> M1 i c f a)
    -> Generic1 (M1 i c f)
    forall (a :: k). M1 i c f a -> Rep1 (M1 i c f) a
    forall (a :: k). Rep1 (M1 i c f) a -> M1 i c f a
    forall i (c :: Meta) k (f :: k -> *) (a :: k).
    M1 i c f a -> Rep1 (M1 i c f) a
    forall i (c :: Meta) k (f :: k -> *) (a :: k).
    Rep1 (M1 i c f) a -> M1 i c f a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall i (c :: Meta) k (f :: k -> *) (a :: k).
    M1 i c f a -> Rep1 (M1 i c f) a
    from1 :: forall (a :: k). M1 i c f a -> Rep1 (M1 i c f) a
    $cto1 :: forall i (c :: Meta) k (f :: k -> *) (a :: k).
    Rep1 (M1 i c f) a -> M1 i c f a
    to1 :: forall (a :: k). Rep1 (M1 i c f) a -> M1 i c f a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | Sums: encode choice between constructors
    infixr 5 :+:
    data (:+:) (f :: k -> Type) (g :: k -> Type) (p :: k) = L1 (f p) | R1 (g p)
      deriving ( (:+:) f g p -> (:+:) f g p -> Bool
    ((:+:) f g p -> (:+:) f g p -> Bool)
    -> ((:+:) f g p -> (:+:) f g p -> Bool) -> Eq ((:+:) f g p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Eq (f p), Eq (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Bool
    $c== :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Eq (f p), Eq (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Bool
    == :: (:+:) f g p -> (:+:) f g p -> Bool
    $c/= :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Eq (f p), Eq (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Bool
    /= :: (:+:) f g p -> (:+:) f g p -> Bool
    Eq       -- ^ @since 4.7.0.0
               , Eq ((:+:) f g p)
    Eq ((:+:) f g p) =>
    ((:+:) f g p -> (:+:) f g p -> Ordering)
    -> ((:+:) f g p -> (:+:) f g p -> Bool)
    -> ((:+:) f g p -> (:+:) f g p -> Bool)
    -> ((:+:) f g p -> (:+:) f g p -> Bool)
    -> ((:+:) f g p -> (:+:) f g p -> Bool)
    -> ((:+:) f g p -> (:+:) f g p -> (:+:) f g p)
    -> ((:+:) f g p -> (:+:) f g p -> (:+:) f g p)
    -> Ord ((:+:) f g p)
    (:+:) f g p -> (:+:) f g p -> Bool
    (:+:) f g p -> (:+:) f g p -> Ordering
    (:+:) f g p -> (:+:) f g p -> (:+:) f g p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    Eq ((:+:) f g p)
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Bool
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Ordering
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> (:+:) f g p
    $ccompare :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Ordering
    compare :: (:+:) f g p -> (:+:) f g p -> Ordering
    $c< :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Bool
    < :: (:+:) f g p -> (:+:) f g p -> Bool
    $c<= :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Bool
    <= :: (:+:) f g p -> (:+:) f g p -> Bool
    $c> :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Bool
    > :: (:+:) f g p -> (:+:) f g p -> Bool
    $c>= :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> Bool
    >= :: (:+:) f g p -> (:+:) f g p -> Bool
    $cmax :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> (:+:) f g p
    max :: (:+:) f g p -> (:+:) f g p -> (:+:) f g p
    $cmin :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:+:) f g p -> (:+:) f g p -> (:+:) f g p
    min :: (:+:) f g p -> (:+:) f g p -> (:+:) f g p
    Ord      -- ^ @since 4.7.0.0
               , ReadPrec [(:+:) f g p]
    ReadPrec ((:+:) f g p)
    Int -> ReadS ((:+:) f g p)
    ReadS [(:+:) f g p]
    (Int -> ReadS ((:+:) f g p))
    -> ReadS [(:+:) f g p]
    -> ReadPrec ((:+:) f g p)
    -> ReadPrec [(:+:) f g p]
    -> Read ((:+:) f g p)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadPrec [(:+:) f g p]
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadPrec ((:+:) f g p)
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    Int -> ReadS ((:+:) f g p)
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadS [(:+:) f g p]
    $creadsPrec :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    Int -> ReadS ((:+:) f g p)
    readsPrec :: Int -> ReadS ((:+:) f g p)
    $creadList :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadS [(:+:) f g p]
    readList :: ReadS [(:+:) f g p]
    $creadPrec :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadPrec ((:+:) f g p)
    readPrec :: ReadPrec ((:+:) f g p)
    $creadListPrec :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadPrec [(:+:) f g p]
    readListPrec :: ReadPrec [(:+:) f g p]
    Read     -- ^ @since 4.7.0.0
               , Int -> (:+:) f g p -> ShowS
    [(:+:) f g p] -> ShowS
    (:+:) f g p -> String
    (Int -> (:+:) f g p -> ShowS)
    -> ((:+:) f g p -> String)
    -> ([(:+:) f g p] -> ShowS)
    -> Show ((:+:) f g p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    Int -> (:+:) f g p -> ShowS
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    [(:+:) f g p] -> ShowS
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    (:+:) f g p -> String
    $cshowsPrec :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    Int -> (:+:) f g p -> ShowS
    showsPrec :: Int -> (:+:) f g p -> ShowS
    $cshow :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    (:+:) f g p -> String
    show :: (:+:) f g p -> String
    $cshowList :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    [(:+:) f g p] -> ShowS
    showList :: [(:+:) f g p] -> ShowS
    Show     -- ^ @since 4.7.0.0
               , (forall a b. (a -> b) -> (:+:) f g a -> (:+:) f g b)
    -> (forall a b. a -> (:+:) f g b -> (:+:) f g a)
    -> Functor (f :+: g)
    forall a b. a -> (:+:) f g b -> (:+:) f g a
    forall a b. (a -> b) -> (:+:) f g a -> (:+:) f g b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    a -> (:+:) f g b -> (:+:) f g a
    forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    (a -> b) -> (:+:) f g a -> (:+:) f g b
    $cfmap :: forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    (a -> b) -> (:+:) f g a -> (:+:) f g b
    fmap :: forall a b. (a -> b) -> (:+:) f g a -> (:+:) f g b
    $c<$ :: forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    a -> (:+:) f g b -> (:+:) f g a
    <$ :: forall a b. a -> (:+:) f g b -> (:+:) f g a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. (:+:) f g p -> Rep ((:+:) f g p) x)
    -> (forall x. Rep ((:+:) f g p) x -> (:+:) f g p)
    -> Generic ((:+:) f g p)
    forall x. (:+:) f g p -> Rep ((:+:) f g p) x
    forall x. Rep ((:+:) f g p) x -> (:+:) f g p
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (f :: k -> *) (g :: k -> *) (p :: k) x.
    (:+:) f g p -> Rep ((:+:) f g p) x
    forall k (f :: k -> *) (g :: k -> *) (p :: k) x.
    Rep ((:+:) f g p) x -> (:+:) f g p
    $cfrom :: forall k (f :: k -> *) (g :: k -> *) (p :: k) x.
    (:+:) f g p -> Rep ((:+:) f g p) x
    from :: forall x. (:+:) f g p -> Rep ((:+:) f g p) x
    $cto :: forall k (f :: k -> *) (g :: k -> *) (p :: k) x.
    Rep ((:+:) f g p) x -> (:+:) f g p
    to :: forall x. Rep ((:+:) f g p) x -> (:+:) f g p
    Generic  -- ^ @since 4.7.0.0
               , (forall (a :: k). (:+:) f g a -> Rep1 (f :+: g) a)
    -> (forall (a :: k). Rep1 (f :+: g) a -> (:+:) f g a)
    -> Generic1 (f :+: g)
    forall (a :: k). (:+:) f g a -> Rep1 (f :+: g) a
    forall (a :: k). Rep1 (f :+: g) a -> (:+:) f g a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    forall k (f :: k -> *) (g :: k -> *) (a :: k).
    (:+:) f g a -> Rep1 (f :+: g) a
    forall k (f :: k -> *) (g :: k -> *) (a :: k).
    Rep1 (f :+: g) a -> (:+:) f g a
    $cfrom1 :: forall k (f :: k -> *) (g :: k -> *) (a :: k).
    (:+:) f g a -> Rep1 (f :+: g) a
    from1 :: forall (a :: k). (:+:) f g a -> Rep1 (f :+: g) a
    $cto1 :: forall k (f :: k -> *) (g :: k -> *) (a :: k).
    Rep1 (f :+: g) a -> (:+:) f g a
    to1 :: forall (a :: k). Rep1 (f :+: g) a -> (:+:) f g a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | Products: encode multiple arguments to constructors
    infixr 6 :*:
    data (:*:) (f :: k -> Type) (g :: k -> Type) (p :: k) = f p :*: g p
      deriving ( (:*:) f g p -> (:*:) f g p -> Bool
    ((:*:) f g p -> (:*:) f g p -> Bool)
    -> ((:*:) f g p -> (:*:) f g p -> Bool) -> Eq ((:*:) f g p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Eq (f p), Eq (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Bool
    $c== :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Eq (f p), Eq (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Bool
    == :: (:*:) f g p -> (:*:) f g p -> Bool
    $c/= :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Eq (f p), Eq (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Bool
    /= :: (:*:) f g p -> (:*:) f g p -> Bool
    Eq       -- ^ @since 4.7.0.0
               , Eq ((:*:) f g p)
    Eq ((:*:) f g p) =>
    ((:*:) f g p -> (:*:) f g p -> Ordering)
    -> ((:*:) f g p -> (:*:) f g p -> Bool)
    -> ((:*:) f g p -> (:*:) f g p -> Bool)
    -> ((:*:) f g p -> (:*:) f g p -> Bool)
    -> ((:*:) f g p -> (:*:) f g p -> Bool)
    -> ((:*:) f g p -> (:*:) f g p -> (:*:) f g p)
    -> ((:*:) f g p -> (:*:) f g p -> (:*:) f g p)
    -> Ord ((:*:) f g p)
    (:*:) f g p -> (:*:) f g p -> Bool
    (:*:) f g p -> (:*:) f g p -> Ordering
    (:*:) f g p -> (:*:) f g p -> (:*:) f g p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    Eq ((:*:) f g p)
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Bool
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Ordering
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> (:*:) f g p
    $ccompare :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Ordering
    compare :: (:*:) f g p -> (:*:) f g p -> Ordering
    $c< :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Bool
    < :: (:*:) f g p -> (:*:) f g p -> Bool
    $c<= :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Bool
    <= :: (:*:) f g p -> (:*:) f g p -> Bool
    $c> :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Bool
    > :: (:*:) f g p -> (:*:) f g p -> Bool
    $c>= :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> Bool
    >= :: (:*:) f g p -> (:*:) f g p -> Bool
    $cmax :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> (:*:) f g p
    max :: (:*:) f g p -> (:*:) f g p -> (:*:) f g p
    $cmin :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Ord (f p), Ord (g p)) =>
    (:*:) f g p -> (:*:) f g p -> (:*:) f g p
    min :: (:*:) f g p -> (:*:) f g p -> (:*:) f g p
    Ord      -- ^ @since 4.7.0.0
               , ReadPrec [(:*:) f g p]
    ReadPrec ((:*:) f g p)
    Int -> ReadS ((:*:) f g p)
    ReadS [(:*:) f g p]
    (Int -> ReadS ((:*:) f g p))
    -> ReadS [(:*:) f g p]
    -> ReadPrec ((:*:) f g p)
    -> ReadPrec [(:*:) f g p]
    -> Read ((:*:) f g p)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadPrec [(:*:) f g p]
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadPrec ((:*:) f g p)
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    Int -> ReadS ((:*:) f g p)
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadS [(:*:) f g p]
    $creadsPrec :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    Int -> ReadS ((:*:) f g p)
    readsPrec :: Int -> ReadS ((:*:) f g p)
    $creadList :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadS [(:*:) f g p]
    readList :: ReadS [(:*:) f g p]
    $creadPrec :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadPrec ((:*:) f g p)
    readPrec :: ReadPrec ((:*:) f g p)
    $creadListPrec :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Read (f p), Read (g p)) =>
    ReadPrec [(:*:) f g p]
    readListPrec :: ReadPrec [(:*:) f g p]
    Read     -- ^ @since 4.7.0.0
               , Int -> (:*:) f g p -> ShowS
    [(:*:) f g p] -> ShowS
    (:*:) f g p -> String
    (Int -> (:*:) f g p -> ShowS)
    -> ((:*:) f g p -> String)
    -> ([(:*:) f g p] -> ShowS)
    -> Show ((:*:) f g p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    Int -> (:*:) f g p -> ShowS
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    [(:*:) f g p] -> ShowS
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    (:*:) f g p -> String
    $cshowsPrec :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    Int -> (:*:) f g p -> ShowS
    showsPrec :: Int -> (:*:) f g p -> ShowS
    $cshow :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    (:*:) f g p -> String
    show :: (:*:) f g p -> String
    $cshowList :: forall k (f :: k -> *) (g :: k -> *) (p :: k).
    (Show (f p), Show (g p)) =>
    [(:*:) f g p] -> ShowS
    showList :: [(:*:) f g p] -> ShowS
    Show     -- ^ @since 4.7.0.0
               , (forall a b. (a -> b) -> (:*:) f g a -> (:*:) f g b)
    -> (forall a b. a -> (:*:) f g b -> (:*:) f g a)
    -> Functor (f :*: g)
    forall a b. a -> (:*:) f g b -> (:*:) f g a
    forall a b. (a -> b) -> (:*:) f g a -> (:*:) f g b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    a -> (:*:) f g b -> (:*:) f g a
    forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    (a -> b) -> (:*:) f g a -> (:*:) f g b
    $cfmap :: forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    (a -> b) -> (:*:) f g a -> (:*:) f g b
    fmap :: forall a b. (a -> b) -> (:*:) f g a -> (:*:) f g b
    $c<$ :: forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    a -> (:*:) f g b -> (:*:) f g a
    <$ :: forall a b. a -> (:*:) f g b -> (:*:) f g a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. (:*:) f g p -> Rep ((:*:) f g p) x)
    -> (forall x. Rep ((:*:) f g p) x -> (:*:) f g p)
    -> Generic ((:*:) f g p)
    forall x. (:*:) f g p -> Rep ((:*:) f g p) x
    forall x. Rep ((:*:) f g p) x -> (:*:) f g p
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (f :: k -> *) (g :: k -> *) (p :: k) x.
    (:*:) f g p -> Rep ((:*:) f g p) x
    forall k (f :: k -> *) (g :: k -> *) (p :: k) x.
    Rep ((:*:) f g p) x -> (:*:) f g p
    $cfrom :: forall k (f :: k -> *) (g :: k -> *) (p :: k) x.
    (:*:) f g p -> Rep ((:*:) f g p) x
    from :: forall x. (:*:) f g p -> Rep ((:*:) f g p) x
    $cto :: forall k (f :: k -> *) (g :: k -> *) (p :: k) x.
    Rep ((:*:) f g p) x -> (:*:) f g p
    to :: forall x. Rep ((:*:) f g p) x -> (:*:) f g p
    Generic  -- ^ @since 4.7.0.0
               , (forall (a :: k). (:*:) f g a -> Rep1 (f :*: g) a)
    -> (forall (a :: k). Rep1 (f :*: g) a -> (:*:) f g a)
    -> Generic1 (f :*: g)
    forall (a :: k). (:*:) f g a -> Rep1 (f :*: g) a
    forall (a :: k). Rep1 (f :*: g) a -> (:*:) f g a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    forall k (f :: k -> *) (g :: k -> *) (a :: k).
    (:*:) f g a -> Rep1 (f :*: g) a
    forall k (f :: k -> *) (g :: k -> *) (a :: k).
    Rep1 (f :*: g) a -> (:*:) f g a
    $cfrom1 :: forall k (f :: k -> *) (g :: k -> *) (a :: k).
    (:*:) f g a -> Rep1 (f :*: g) a
    from1 :: forall (a :: k). (:*:) f g a -> Rep1 (f :*: g) a
    $cto1 :: forall k (f :: k -> *) (g :: k -> *) (a :: k).
    Rep1 (f :*: g) a -> (:*:) f g a
    to1 :: forall (a :: k). Rep1 (f :*: g) a -> (:*:) f g a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    instance (Applicative f, Applicative g) => Applicative (f :*: g) where
      pure :: forall a. a -> (:*:) f g a
    pure a
    a = a -> f a
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    a f a -> g a -> (:*:) f g a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*: a -> g a
    forall a. a -> g a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    a
      (f (a -> b)
    f :*: g (a -> b)
    g) <*> :: forall a b. (:*:) f g (a -> b) -> (:*:) f g a -> (:*:) f g b
    <*> (f a
    x :*: g a
    y) = (f (a -> b)
    f f (a -> b) -> f a -> f b
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> f a
    x) f b -> g b -> (:*:) f g b
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*: (g (a -> b)
    g g (a -> b) -> g a -> g b
    forall a b. g (a -> b) -> g a -> g b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> g a
    y)
      liftA2 :: forall a b c.
    (a -> b -> c) -> (:*:) f g a -> (:*:) f g b -> (:*:) f g c
    liftA2 a -> b -> c
    f (f a
    a :*: g a
    b) (f b
    x :*: g b
    y) = (a -> b -> c) -> f a -> f b -> f c
    forall a b c. (a -> b -> c) -> f a -> f b -> f c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 a -> b -> c
    f f a
    a f b
    x f c -> g c -> (:*:) f g c
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*: (a -> b -> c) -> g a -> g b -> g c
    forall a b c. (a -> b -> c) -> g a -> g b -> g c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 a -> b -> c
    f g a
    b g b
    y

    -- | @since 4.9.0.0
    instance (Alternative f, Alternative g) => Alternative (f :*: g) where
      empty :: forall a. (:*:) f g a
    empty = f a
    forall a. f a
    forall (f :: * -> *) a. Alternative f => f a
    empty f a -> g a -> (:*:) f g a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*: g a
    forall a. g a
    forall (f :: * -> *) a. Alternative f => f a
    empty
      (f a
    x1 :*: g a
    y1) <|> :: forall a. (:*:) f g a -> (:*:) f g a -> (:*:) f g a
    <|> (f a
    x2 :*: g a
    y2) = (f a
    x1 f a -> f a -> f a
    forall a. f a -> f a -> f a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> f a
    x2) f a -> g a -> (:*:) f g a
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*: (g a
    y1 g a -> g a -> g a
    forall a. g a -> g a -> g a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> g a
    y2)

    -- | @since 4.9.0.0
    instance (Monad f, Monad g) => Monad (f :*: g) where
      (f a
    m :*: g a
    n) >>= :: forall a b. (:*:) f g a -> (a -> (:*:) f g b) -> (:*:) f g b
    >>= a -> (:*:) f g b
    f = (f a
    m f a -> (a -> f b) -> f b
    forall a b. f a -> (a -> f b) -> f b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \a
    a -> (:*:) f g b -> f b
    forall {k} {f :: k -> *} {g :: k -> *} {p :: k}. (:*:) f g p -> f p
    fstP (a -> (:*:) f g b
    f a
    a)) f b -> g b -> (:*:) f g b
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*: (g a
    n g a -> (a -> g b) -> g b
    forall a b. g a -> (a -> g b) -> g b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \a
    a -> (:*:) f g b -> g b
    forall {k} {f :: k -> *} {g :: k -> *} {p :: k}. (:*:) f g p -> g p
    sndP (a -> (:*:) f g b
    f a
    a))
        where
          fstP :: (:*:) f g p -> f p
    fstP (f p
    a :*: g p
    _) = f p
    a
          sndP :: (:*:) f g p -> g p
    sndP (f p
    _ :*: g p
    b) = g p
    b

    -- | @since 4.9.0.0
    instance (MonadPlus f, MonadPlus g) => MonadPlus (f :*: g)

    -- | @since 4.12.0.0
    instance (Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) where
      (f p
    x1 :*: g p
    y1) <> :: (:*:) f g p -> (:*:) f g p -> (:*:) f g p
    <> (f p
    x2 :*: g p
    y2) = (f p
    x1 f p -> f p -> f p
    forall a. Semigroup a => a -> a -> a
    <> f p
    x2) f p -> g p -> (:*:) f g p
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*: (g p
    y1 g p -> g p -> g p
    forall a. Semigroup a => a -> a -> a
    <> g p
    y2)

    -- | @since 4.12.0.0
    instance (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) where
      mempty :: (:*:) f g p
    mempty = f p
    forall a. Monoid a => a
    mempty f p -> g p -> (:*:) f g p
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    :*: g p
    forall a. Monoid a => a
    mempty

    -- | Composition of functors
    infixr 7 :.:
    newtype (:.:) (f :: k2 -> Type) (g :: k1 -> k2) (p :: k1) =
        Comp1 { forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
    (:.:) f g p -> f (g p)
    unComp1 :: f (g p) }
      deriving ( (:.:) f g p -> (:.:) f g p -> Bool
    ((:.:) f g p -> (:.:) f g p -> Bool)
    -> ((:.:) f g p -> (:.:) f g p -> Bool) -> Eq ((:.:) f g p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Eq (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Bool
    $c== :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Eq (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Bool
    == :: (:.:) f g p -> (:.:) f g p -> Bool
    $c/= :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Eq (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Bool
    /= :: (:.:) f g p -> (:.:) f g p -> Bool
    Eq       -- ^ @since 4.7.0.0
               , Eq ((:.:) f g p)
    Eq ((:.:) f g p) =>
    ((:.:) f g p -> (:.:) f g p -> Ordering)
    -> ((:.:) f g p -> (:.:) f g p -> Bool)
    -> ((:.:) f g p -> (:.:) f g p -> Bool)
    -> ((:.:) f g p -> (:.:) f g p -> Bool)
    -> ((:.:) f g p -> (:.:) f g p -> Bool)
    -> ((:.:) f g p -> (:.:) f g p -> (:.:) f g p)
    -> ((:.:) f g p -> (:.:) f g p -> (:.:) f g p)
    -> Ord ((:.:) f g p)
    (:.:) f g p -> (:.:) f g p -> Bool
    (:.:) f g p -> (:.:) f g p -> Ordering
    (:.:) f g p -> (:.:) f g p -> (:.:) f g p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    Eq ((:.:) f g p)
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Bool
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Ordering
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> (:.:) f g p
    $ccompare :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Ordering
    compare :: (:.:) f g p -> (:.:) f g p -> Ordering
    $c< :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Bool
    < :: (:.:) f g p -> (:.:) f g p -> Bool
    $c<= :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Bool
    <= :: (:.:) f g p -> (:.:) f g p -> Bool
    $c> :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Bool
    > :: (:.:) f g p -> (:.:) f g p -> Bool
    $c>= :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> Bool
    >= :: (:.:) f g p -> (:.:) f g p -> Bool
    $cmax :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> (:.:) f g p
    max :: (:.:) f g p -> (:.:) f g p -> (:.:) f g p
    $cmin :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Ord (f (g p)) =>
    (:.:) f g p -> (:.:) f g p -> (:.:) f g p
    min :: (:.:) f g p -> (:.:) f g p -> (:.:) f g p
    Ord      -- ^ @since 4.7.0.0
               , ReadPrec [(:.:) f g p]
    ReadPrec ((:.:) f g p)
    Int -> ReadS ((:.:) f g p)
    ReadS [(:.:) f g p]
    (Int -> ReadS ((:.:) f g p))
    -> ReadS [(:.:) f g p]
    -> ReadPrec ((:.:) f g p)
    -> ReadPrec [(:.:) f g p]
    -> Read ((:.:) f g p)
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Read (f (g p)) =>
    ReadPrec [(:.:) f g p]
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Read (f (g p)) =>
    ReadPrec ((:.:) f g p)
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Read (f (g p)) =>
    Int -> ReadS ((:.:) f g p)
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Read (f (g p)) =>
    ReadS [(:.:) f g p]
    $creadsPrec :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Read (f (g p)) =>
    Int -> ReadS ((:.:) f g p)
    readsPrec :: Int -> ReadS ((:.:) f g p)
    $creadList :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Read (f (g p)) =>
    ReadS [(:.:) f g p]
    readList :: ReadS [(:.:) f g p]
    $creadPrec :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Read (f (g p)) =>
    ReadPrec ((:.:) f g p)
    readPrec :: ReadPrec ((:.:) f g p)
    $creadListPrec :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Read (f (g p)) =>
    ReadPrec [(:.:) f g p]
    readListPrec :: ReadPrec [(:.:) f g p]
    Read     -- ^ @since 4.7.0.0
               , Int -> (:.:) f g p -> ShowS
    [(:.:) f g p] -> ShowS
    (:.:) f g p -> String
    (Int -> (:.:) f g p -> ShowS)
    -> ((:.:) f g p -> String)
    -> ([(:.:) f g p] -> ShowS)
    -> Show ((:.:) f g p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Show (f (g p)) =>
    Int -> (:.:) f g p -> ShowS
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Show (f (g p)) =>
    [(:.:) f g p] -> ShowS
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Show (f (g p)) =>
    (:.:) f g p -> String
    $cshowsPrec :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Show (f (g p)) =>
    Int -> (:.:) f g p -> ShowS
    showsPrec :: Int -> (:.:) f g p -> ShowS
    $cshow :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Show (f (g p)) =>
    (:.:) f g p -> String
    show :: (:.:) f g p -> String
    $cshowList :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1).
    Show (f (g p)) =>
    [(:.:) f g p] -> ShowS
    showList :: [(:.:) f g p] -> ShowS
    Show     -- ^ @since 4.7.0.0
               , (forall a b. (a -> b) -> (:.:) f g a -> (:.:) f g b)
    -> (forall a b. a -> (:.:) f g b -> (:.:) f g a)
    -> Functor (f :.: g)
    forall a b. a -> (:.:) f g b -> (:.:) f g a
    forall a b. (a -> b) -> (:.:) f g a -> (:.:) f g b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    a -> (:.:) f g b -> (:.:) f g a
    forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    (a -> b) -> (:.:) f g a -> (:.:) f g b
    $cfmap :: forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    (a -> b) -> (:.:) f g a -> (:.:) f g b
    fmap :: forall a b. (a -> b) -> (:.:) f g a -> (:.:) f g b
    $c<$ :: forall (f :: * -> *) (g :: * -> *) a b.
    (Functor f, Functor g) =>
    a -> (:.:) f g b -> (:.:) f g a
    <$ :: forall a b. a -> (:.:) f g b -> (:.:) f g a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. (:.:) f g p -> Rep ((:.:) f g p) x)
    -> (forall x. Rep ((:.:) f g p) x -> (:.:) f g p)
    -> Generic ((:.:) f g p)
    forall x. (:.:) f g p -> Rep ((:.:) f g p) x
    forall x. Rep ((:.:) f g p) x -> (:.:) f g p
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1) x.
    (:.:) f g p -> Rep ((:.:) f g p) x
    forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1) x.
    Rep ((:.:) f g p) x -> (:.:) f g p
    $cfrom :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1) x.
    (:.:) f g p -> Rep ((:.:) f g p) x
    from :: forall x. (:.:) f g p -> Rep ((:.:) f g p) x
    $cto :: forall k2 (f :: k2 -> *) k1 (g :: k1 -> k2) (p :: k1) x.
    Rep ((:.:) f g p) x -> (:.:) f g p
    to :: forall x. Rep ((:.:) f g p) x -> (:.:) f g p
    Generic  -- ^ @since 4.7.0.0
               , (forall (a :: k). (:.:) f g a -> Rep1 (f :.: g) a)
    -> (forall (a :: k). Rep1 (f :.: g) a -> (:.:) f g a)
    -> Generic1 (f :.: g)
    forall (a :: k). (:.:) f g a -> Rep1 (f :.: g) a
    forall (a :: k). Rep1 (f :.: g) a -> (:.:) f g a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    forall (f :: * -> *) k (g :: k -> *) (a :: k).
    Functor f =>
    (:.:) f g a -> Rep1 (f :.: g) a
    forall (f :: * -> *) k (g :: k -> *) (a :: k).
    Functor f =>
    Rep1 (f :.: g) a -> (:.:) f g a
    $cfrom1 :: forall (f :: * -> *) k (g :: k -> *) (a :: k).
    Functor f =>
    (:.:) f g a -> Rep1 (f :.: g) a
    from1 :: forall (a :: k). (:.:) f g a -> Rep1 (f :.: g) a
    $cto1 :: forall (f :: * -> *) k (g :: k -> *) (a :: k).
    Functor f =>
    Rep1 (f :.: g) a -> (:.:) f g a
    to1 :: forall (a :: k). Rep1 (f :.: g) a -> (:.:) f g a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | @since 4.9.0.0
    instance (Applicative f, Applicative g) => Applicative (f :.: g) where
      pure :: forall a. a -> (:.:) f g a
    pure a
    x = f (g a) -> (:.:) f g a
    forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
    f (g p) -> (:.:) f g p
    Comp1 (g a -> f (g a)
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (a -> g a
    forall a. a -> g a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    x))
      Comp1 f (g (a -> b))
    f <*> :: forall a b. (:.:) f g (a -> b) -> (:.:) f g a -> (:.:) f g b
    <*> Comp1 f (g a)
    x = f (g b) -> (:.:) f g b
    forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
    f (g p) -> (:.:) f g p
    Comp1 ((g (a -> b) -> g a -> g b) -> f (g (a -> b)) -> f (g a) -> f (g b)
    forall a b c. (a -> b -> c) -> f a -> f b -> f c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 g (a -> b) -> g a -> g b
    forall a b. g (a -> b) -> g a -> g b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    (<*>) f (g (a -> b))
    f f (g a)
    x)
      liftA2 :: forall a b c.
    (a -> b -> c) -> (:.:) f g a -> (:.:) f g b -> (:.:) f g c
    liftA2 a -> b -> c
    f (Comp1 f (g a)
    x) (Comp1 f (g b)
    y) = f (g c) -> (:.:) f g c
    forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
    f (g p) -> (:.:) f g p
    Comp1 ((g a -> g b -> g c) -> f (g a) -> f (g b) -> f (g c)
    forall a b c. (a -> b -> c) -> f a -> f b -> f c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 ((a -> b -> c) -> g a -> g b -> g c
    forall a b c. (a -> b -> c) -> g a -> g b -> g c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 a -> b -> c
    f) f (g a)
    x f (g b)
    y)

    -- | @since 4.9.0.0
    instance (Alternative f, Applicative g) => Alternative (f :.: g) where
      empty :: forall a. (:.:) f g a
    empty = f (g a) -> (:.:) f g a
    forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1).
    f (g p) -> (:.:) f g p
    Comp1 f (g a)
    forall a. f a
    forall (f :: * -> *) a. Alternative f => f a
    empty
      <|> :: forall a. (:.:) f g a -> (:.:) f g a -> (:.:) f g a
    (<|>) = (f (g a) -> f (g a) -> f (g a))
    -> (:.:) f g a -> (:.:) f g a -> (:.:) f g a
    forall a b. Coercible a b => a -> b
    coerce (f (g a) -> f (g a) -> f (g a)
    forall a. f a -> f a -> f a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    (<|>) :: f (g a) -> f (g a) -> f (g a)) ::
        forall a . (f :.: g) a -> (f :.: g) a -> (f :.: g) a

    -- | @since 4.12.0.0
    deriving instance Semigroup (f (g p)) => Semigroup ((f :.: g) p)

    -- | @since 4.12.0.0
    deriving instance Monoid (f (g p)) => Monoid ((f :.: g) p)

    -- | Constants of unlifted kinds
    --
    -- @since 4.9.0.0
    data family URec (a :: Type) (p :: k)

    -- | Used for marking occurrences of 'Addr#'
    --
    -- @since 4.9.0.0
    data instance URec (Ptr ()) (p :: k) = UAddr { forall k (p :: k). URec (Ptr ()) p -> Addr#
    uAddr# :: Addr# }
      deriving ( URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    (URec (Ptr ()) p -> URec (Ptr ()) p -> Bool)
    -> (URec (Ptr ()) p -> URec (Ptr ()) p -> Bool)
    -> Eq (URec (Ptr ()) p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    $c== :: forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    == :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    $c/= :: forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    /= :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (URec (Ptr ()) p)
    Eq (URec (Ptr ()) p) =>
    (URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering)
    -> (URec (Ptr ()) p -> URec (Ptr ()) p -> Bool)
    -> (URec (Ptr ()) p -> URec (Ptr ()) p -> Bool)
    -> (URec (Ptr ()) p -> URec (Ptr ()) p -> Bool)
    -> (URec (Ptr ()) p -> URec (Ptr ()) p -> Bool)
    -> (URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p)
    -> (URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p)
    -> Ord (URec (Ptr ()) p)
    URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering
    URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (p :: k). Eq (URec (Ptr ()) p)
    forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering
    forall k (p :: k).
    URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p
    $ccompare :: forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering
    compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering
    $c< :: forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    < :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    $c<= :: forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    <= :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    $c> :: forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    > :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    $c>= :: forall k (p :: k). URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    >= :: URec (Ptr ()) p -> URec (Ptr ()) p -> Bool
    $cmax :: forall k (p :: k).
    URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p
    max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p
    $cmin :: forall k (p :: k).
    URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p
    min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p
    Ord      -- ^ @since 4.9.0.0
               , (forall a b. (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b)
    -> (forall a b. a -> URec (Ptr ()) b -> URec (Ptr ()) a)
    -> Functor (URec (Ptr ()))
    forall a b. a -> URec (Ptr ()) b -> URec (Ptr ()) a
    forall a b. (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b
    fmap :: forall a b. (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b
    $c<$ :: forall a b. a -> URec (Ptr ()) b -> URec (Ptr ()) a
    <$ :: forall a b. a -> URec (Ptr ()) b -> URec (Ptr ()) a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x)
    -> (forall x. Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p)
    -> Generic (URec (Ptr ()) p)
    forall x. Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p
    forall x. URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (p :: k) x. Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p
    forall k (p :: k) x. URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x
    $cfrom :: forall k (p :: k) x. URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x
    from :: forall x. URec (Ptr ()) p -> Rep (URec (Ptr ()) p) x
    $cto :: forall k (p :: k) x. Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p
    to :: forall x. Rep (URec (Ptr ()) p) x -> URec (Ptr ()) p
    Generic  -- ^ @since 4.9.0.0
               , (forall (a :: k). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a)
    -> (forall (a :: k). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a)
    -> Generic1 (URec (Ptr ()))
    forall (a :: k). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a
    forall (a :: k). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a
    forall k (a :: k). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a
    forall k (a :: k). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k (a :: k). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a
    from1 :: forall (a :: k). URec (Ptr ()) a -> Rep1 (URec (Ptr ())) a
    $cto1 :: forall k (a :: k). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a
    to1 :: forall (a :: k). Rep1 (URec (Ptr ())) a -> URec (Ptr ()) a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | Used for marking occurrences of 'Char#'
    --
    -- @since 4.9.0.0
    data instance URec Char (p :: k) = UChar { forall k (p :: k). URec Char p -> Char#
    uChar# :: Char# }
      deriving ( URec Char p -> URec Char p -> Bool
    (URec Char p -> URec Char p -> Bool)
    -> (URec Char p -> URec Char p -> Bool) -> Eq (URec Char p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (p :: k). URec Char p -> URec Char p -> Bool
    $c== :: forall k (p :: k). URec Char p -> URec Char p -> Bool
    == :: URec Char p -> URec Char p -> Bool
    $c/= :: forall k (p :: k). URec Char p -> URec Char p -> Bool
    /= :: URec Char p -> URec Char p -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (URec Char p)
    Eq (URec Char p) =>
    (URec Char p -> URec Char p -> Ordering)
    -> (URec Char p -> URec Char p -> Bool)
    -> (URec Char p -> URec Char p -> Bool)
    -> (URec Char p -> URec Char p -> Bool)
    -> (URec Char p -> URec Char p -> Bool)
    -> (URec Char p -> URec Char p -> URec Char p)
    -> (URec Char p -> URec Char p -> URec Char p)
    -> Ord (URec Char p)
    URec Char p -> URec Char p -> Bool
    URec Char p -> URec Char p -> Ordering
    URec Char p -> URec Char p -> URec Char p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (p :: k). Eq (URec Char p)
    forall k (p :: k). URec Char p -> URec Char p -> Bool
    forall k (p :: k). URec Char p -> URec Char p -> Ordering
    forall k (p :: k). URec Char p -> URec Char p -> URec Char p
    $ccompare :: forall k (p :: k). URec Char p -> URec Char p -> Ordering
    compare :: URec Char p -> URec Char p -> Ordering
    $c< :: forall k (p :: k). URec Char p -> URec Char p -> Bool
    < :: URec Char p -> URec Char p -> Bool
    $c<= :: forall k (p :: k). URec Char p -> URec Char p -> Bool
    <= :: URec Char p -> URec Char p -> Bool
    $c> :: forall k (p :: k). URec Char p -> URec Char p -> Bool
    > :: URec Char p -> URec Char p -> Bool
    $c>= :: forall k (p :: k). URec Char p -> URec Char p -> Bool
    >= :: URec Char p -> URec Char p -> Bool
    $cmax :: forall k (p :: k). URec Char p -> URec Char p -> URec Char p
    max :: URec Char p -> URec Char p -> URec Char p
    $cmin :: forall k (p :: k). URec Char p -> URec Char p -> URec Char p
    min :: URec Char p -> URec Char p -> URec Char p
    Ord      -- ^ @since 4.9.0.0
               , Int -> URec Char p -> ShowS
    [URec Char p] -> ShowS
    URec Char p -> String
    (Int -> URec Char p -> ShowS)
    -> (URec Char p -> String)
    -> ([URec Char p] -> ShowS)
    -> Show (URec Char p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (p :: k). Int -> URec Char p -> ShowS
    forall k (p :: k). [URec Char p] -> ShowS
    forall k (p :: k). URec Char p -> String
    $cshowsPrec :: forall k (p :: k). Int -> URec Char p -> ShowS
    showsPrec :: Int -> URec Char p -> ShowS
    $cshow :: forall k (p :: k). URec Char p -> String
    show :: URec Char p -> String
    $cshowList :: forall k (p :: k). [URec Char p] -> ShowS
    showList :: [URec Char p] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , (forall a b. (a -> b) -> URec Char a -> URec Char b)
    -> (forall a b. a -> URec Char b -> URec Char a)
    -> Functor (URec Char)
    forall a b. a -> URec Char b -> URec Char a
    forall a b. (a -> b) -> URec Char a -> URec Char b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> URec Char a -> URec Char b
    fmap :: forall a b. (a -> b) -> URec Char a -> URec Char b
    $c<$ :: forall a b. a -> URec Char b -> URec Char a
    <$ :: forall a b. a -> URec Char b -> URec Char a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. URec Char p -> Rep (URec Char p) x)
    -> (forall x. Rep (URec Char p) x -> URec Char p)
    -> Generic (URec Char p)
    forall x. Rep (URec Char p) x -> URec Char p
    forall x. URec Char p -> Rep (URec Char p) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (p :: k) x. Rep (URec Char p) x -> URec Char p
    forall k (p :: k) x. URec Char p -> Rep (URec Char p) x
    $cfrom :: forall k (p :: k) x. URec Char p -> Rep (URec Char p) x
    from :: forall x. URec Char p -> Rep (URec Char p) x
    $cto :: forall k (p :: k) x. Rep (URec Char p) x -> URec Char p
    to :: forall x. Rep (URec Char p) x -> URec Char p
    Generic  -- ^ @since 4.9.0.0
               , (forall (a :: k). URec Char a -> Rep1 (URec Char) a)
    -> (forall (a :: k). Rep1 (URec Char) a -> URec Char a)
    -> Generic1 (URec Char)
    forall (a :: k). Rep1 (URec Char) a -> URec Char a
    forall (a :: k). URec Char a -> Rep1 (URec Char) a
    forall k (a :: k). Rep1 (URec Char) a -> URec Char a
    forall k (a :: k). URec Char a -> Rep1 (URec Char) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k (a :: k). URec Char a -> Rep1 (URec Char) a
    from1 :: forall (a :: k). URec Char a -> Rep1 (URec Char) a
    $cto1 :: forall k (a :: k). Rep1 (URec Char) a -> URec Char a
    to1 :: forall (a :: k). Rep1 (URec Char) a -> URec Char a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | Used for marking occurrences of 'Double#'
    --
    -- @since 4.9.0.0
    data instance URec Double (p :: k) = UDouble { forall k (p :: k). URec Double p -> Double#
    uDouble# :: Double# }
      deriving ( URec Double p -> URec Double p -> Bool
    (URec Double p -> URec Double p -> Bool)
    -> (URec Double p -> URec Double p -> Bool) -> Eq (URec Double p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (p :: k). URec Double p -> URec Double p -> Bool
    $c== :: forall k (p :: k). URec Double p -> URec Double p -> Bool
    == :: URec Double p -> URec Double p -> Bool
    $c/= :: forall k (p :: k). URec Double p -> URec Double p -> Bool
    /= :: URec Double p -> URec Double p -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (URec Double p)
    Eq (URec Double p) =>
    (URec Double p -> URec Double p -> Ordering)
    -> (URec Double p -> URec Double p -> Bool)
    -> (URec Double p -> URec Double p -> Bool)
    -> (URec Double p -> URec Double p -> Bool)
    -> (URec Double p -> URec Double p -> Bool)
    -> (URec Double p -> URec Double p -> URec Double p)
    -> (URec Double p -> URec Double p -> URec Double p)
    -> Ord (URec Double p)
    URec Double p -> URec Double p -> Bool
    URec Double p -> URec Double p -> Ordering
    URec Double p -> URec Double p -> URec Double p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (p :: k). Eq (URec Double p)
    forall k (p :: k). URec Double p -> URec Double p -> Bool
    forall k (p :: k). URec Double p -> URec Double p -> Ordering
    forall k (p :: k). URec Double p -> URec Double p -> URec Double p
    $ccompare :: forall k (p :: k). URec Double p -> URec Double p -> Ordering
    compare :: URec Double p -> URec Double p -> Ordering
    $c< :: forall k (p :: k). URec Double p -> URec Double p -> Bool
    < :: URec Double p -> URec Double p -> Bool
    $c<= :: forall k (p :: k). URec Double p -> URec Double p -> Bool
    <= :: URec Double p -> URec Double p -> Bool
    $c> :: forall k (p :: k). URec Double p -> URec Double p -> Bool
    > :: URec Double p -> URec Double p -> Bool
    $c>= :: forall k (p :: k). URec Double p -> URec Double p -> Bool
    >= :: URec Double p -> URec Double p -> Bool
    $cmax :: forall k (p :: k). URec Double p -> URec Double p -> URec Double p
    max :: URec Double p -> URec Double p -> URec Double p
    $cmin :: forall k (p :: k). URec Double p -> URec Double p -> URec Double p
    min :: URec Double p -> URec Double p -> URec Double p
    Ord      -- ^ @since 4.9.0.0
               , Int -> URec Double p -> ShowS
    [URec Double p] -> ShowS
    URec Double p -> String
    (Int -> URec Double p -> ShowS)
    -> (URec Double p -> String)
    -> ([URec Double p] -> ShowS)
    -> Show (URec Double p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (p :: k). Int -> URec Double p -> ShowS
    forall k (p :: k). [URec Double p] -> ShowS
    forall k (p :: k). URec Double p -> String
    $cshowsPrec :: forall k (p :: k). Int -> URec Double p -> ShowS
    showsPrec :: Int -> URec Double p -> ShowS
    $cshow :: forall k (p :: k). URec Double p -> String
    show :: URec Double p -> String
    $cshowList :: forall k (p :: k). [URec Double p] -> ShowS
    showList :: [URec Double p] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , (forall a b. (a -> b) -> URec Double a -> URec Double b)
    -> (forall a b. a -> URec Double b -> URec Double a)
    -> Functor (URec Double)
    forall a b. a -> URec Double b -> URec Double a
    forall a b. (a -> b) -> URec Double a -> URec Double b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> URec Double a -> URec Double b
    fmap :: forall a b. (a -> b) -> URec Double a -> URec Double b
    $c<$ :: forall a b. a -> URec Double b -> URec Double a
    <$ :: forall a b. a -> URec Double b -> URec Double a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. URec Double p -> Rep (URec Double p) x)
    -> (forall x. Rep (URec Double p) x -> URec Double p)
    -> Generic (URec Double p)
    forall x. Rep (URec Double p) x -> URec Double p
    forall x. URec Double p -> Rep (URec Double p) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (p :: k) x. Rep (URec Double p) x -> URec Double p
    forall k (p :: k) x. URec Double p -> Rep (URec Double p) x
    $cfrom :: forall k (p :: k) x. URec Double p -> Rep (URec Double p) x
    from :: forall x. URec Double p -> Rep (URec Double p) x
    $cto :: forall k (p :: k) x. Rep (URec Double p) x -> URec Double p
    to :: forall x. Rep (URec Double p) x -> URec Double p
    Generic  -- ^ @since 4.9.0.0
               , (forall (a :: k). URec Double a -> Rep1 (URec Double) a)
    -> (forall (a :: k). Rep1 (URec Double) a -> URec Double a)
    -> Generic1 (URec Double)
    forall (a :: k). Rep1 (URec Double) a -> URec Double a
    forall (a :: k). URec Double a -> Rep1 (URec Double) a
    forall k (a :: k). Rep1 (URec Double) a -> URec Double a
    forall k (a :: k). URec Double a -> Rep1 (URec Double) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k (a :: k). URec Double a -> Rep1 (URec Double) a
    from1 :: forall (a :: k). URec Double a -> Rep1 (URec Double) a
    $cto1 :: forall k (a :: k). Rep1 (URec Double) a -> URec Double a
    to1 :: forall (a :: k). Rep1 (URec Double) a -> URec Double a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | Used for marking occurrences of 'Float#'
    --
    -- @since 4.9.0.0
    data instance URec Float (p :: k) = UFloat { forall k (p :: k). URec Float p -> Float#
    uFloat# :: Float# }
      deriving ( URec Float p -> URec Float p -> Bool
    (URec Float p -> URec Float p -> Bool)
    -> (URec Float p -> URec Float p -> Bool) -> Eq (URec Float p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (p :: k). URec Float p -> URec Float p -> Bool
    $c== :: forall k (p :: k). URec Float p -> URec Float p -> Bool
    == :: URec Float p -> URec Float p -> Bool
    $c/= :: forall k (p :: k). URec Float p -> URec Float p -> Bool
    /= :: URec Float p -> URec Float p -> Bool
    Eq, Eq (URec Float p)
    Eq (URec Float p) =>
    (URec Float p -> URec Float p -> Ordering)
    -> (URec Float p -> URec Float p -> Bool)
    -> (URec Float p -> URec Float p -> Bool)
    -> (URec Float p -> URec Float p -> Bool)
    -> (URec Float p -> URec Float p -> Bool)
    -> (URec Float p -> URec Float p -> URec Float p)
    -> (URec Float p -> URec Float p -> URec Float p)
    -> Ord (URec Float p)
    URec Float p -> URec Float p -> Bool
    URec Float p -> URec Float p -> Ordering
    URec Float p -> URec Float p -> URec Float p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (p :: k). Eq (URec Float p)
    forall k (p :: k). URec Float p -> URec Float p -> Bool
    forall k (p :: k). URec Float p -> URec Float p -> Ordering
    forall k (p :: k). URec Float p -> URec Float p -> URec Float p
    $ccompare :: forall k (p :: k). URec Float p -> URec Float p -> Ordering
    compare :: URec Float p -> URec Float p -> Ordering
    $c< :: forall k (p :: k). URec Float p -> URec Float p -> Bool
    < :: URec Float p -> URec Float p -> Bool
    $c<= :: forall k (p :: k). URec Float p -> URec Float p -> Bool
    <= :: URec Float p -> URec Float p -> Bool
    $c> :: forall k (p :: k). URec Float p -> URec Float p -> Bool
    > :: URec Float p -> URec Float p -> Bool
    $c>= :: forall k (p :: k). URec Float p -> URec Float p -> Bool
    >= :: URec Float p -> URec Float p -> Bool
    $cmax :: forall k (p :: k). URec Float p -> URec Float p -> URec Float p
    max :: URec Float p -> URec Float p -> URec Float p
    $cmin :: forall k (p :: k). URec Float p -> URec Float p -> URec Float p
    min :: URec Float p -> URec Float p -> URec Float p
    Ord, Int -> URec Float p -> ShowS
    [URec Float p] -> ShowS
    URec Float p -> String
    (Int -> URec Float p -> ShowS)
    -> (URec Float p -> String)
    -> ([URec Float p] -> ShowS)
    -> Show (URec Float p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (p :: k). Int -> URec Float p -> ShowS
    forall k (p :: k). [URec Float p] -> ShowS
    forall k (p :: k). URec Float p -> String
    $cshowsPrec :: forall k (p :: k). Int -> URec Float p -> ShowS
    showsPrec :: Int -> URec Float p -> ShowS
    $cshow :: forall k (p :: k). URec Float p -> String
    show :: URec Float p -> String
    $cshowList :: forall k (p :: k). [URec Float p] -> ShowS
    showList :: [URec Float p] -> ShowS
    Show
               , (forall a b. (a -> b) -> URec Float a -> URec Float b)
    -> (forall a b. a -> URec Float b -> URec Float a)
    -> Functor (URec Float)
    forall a b. a -> URec Float b -> URec Float a
    forall a b. (a -> b) -> URec Float a -> URec Float b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> URec Float a -> URec Float b
    fmap :: forall a b. (a -> b) -> URec Float a -> URec Float b
    $c<$ :: forall a b. a -> URec Float b -> URec Float a
    <$ :: forall a b. a -> URec Float b -> URec Float a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. URec Float p -> Rep (URec Float p) x)
    -> (forall x. Rep (URec Float p) x -> URec Float p)
    -> Generic (URec Float p)
    forall x. Rep (URec Float p) x -> URec Float p
    forall x. URec Float p -> Rep (URec Float p) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (p :: k) x. Rep (URec Float p) x -> URec Float p
    forall k (p :: k) x. URec Float p -> Rep (URec Float p) x
    $cfrom :: forall k (p :: k) x. URec Float p -> Rep (URec Float p) x
    from :: forall x. URec Float p -> Rep (URec Float p) x
    $cto :: forall k (p :: k) x. Rep (URec Float p) x -> URec Float p
    to :: forall x. Rep (URec Float p) x -> URec Float p
    Generic
               , (forall (a :: k). URec Float a -> Rep1 (URec Float) a)
    -> (forall (a :: k). Rep1 (URec Float) a -> URec Float a)
    -> Generic1 (URec Float)
    forall (a :: k). Rep1 (URec Float) a -> URec Float a
    forall (a :: k). URec Float a -> Rep1 (URec Float) a
    forall k (a :: k). Rep1 (URec Float) a -> URec Float a
    forall k (a :: k). URec Float a -> Rep1 (URec Float) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k (a :: k). URec Float a -> Rep1 (URec Float) a
    from1 :: forall (a :: k). URec Float a -> Rep1 (URec Float) a
    $cto1 :: forall k (a :: k). Rep1 (URec Float) a -> URec Float a
    to1 :: forall (a :: k). Rep1 (URec Float) a -> URec Float a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | Used for marking occurrences of 'Int#'
    --
    -- @since 4.9.0.0
    data instance URec Int (p :: k) = UInt { forall k (p :: k). URec Int p -> Int#
    uInt# :: Int# }
      deriving ( URec Int p -> URec Int p -> Bool
    (URec Int p -> URec Int p -> Bool)
    -> (URec Int p -> URec Int p -> Bool) -> Eq (URec Int p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (p :: k). URec Int p -> URec Int p -> Bool
    $c== :: forall k (p :: k). URec Int p -> URec Int p -> Bool
    == :: URec Int p -> URec Int p -> Bool
    $c/= :: forall k (p :: k). URec Int p -> URec Int p -> Bool
    /= :: URec Int p -> URec Int p -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (URec Int p)
    Eq (URec Int p) =>
    (URec Int p -> URec Int p -> Ordering)
    -> (URec Int p -> URec Int p -> Bool)
    -> (URec Int p -> URec Int p -> Bool)
    -> (URec Int p -> URec Int p -> Bool)
    -> (URec Int p -> URec Int p -> Bool)
    -> (URec Int p -> URec Int p -> URec Int p)
    -> (URec Int p -> URec Int p -> URec Int p)
    -> Ord (URec Int p)
    URec Int p -> URec Int p -> Bool
    URec Int p -> URec Int p -> Ordering
    URec Int p -> URec Int p -> URec Int p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (p :: k). Eq (URec Int p)
    forall k (p :: k). URec Int p -> URec Int p -> Bool
    forall k (p :: k). URec Int p -> URec Int p -> Ordering
    forall k (p :: k). URec Int p -> URec Int p -> URec Int p
    $ccompare :: forall k (p :: k). URec Int p -> URec Int p -> Ordering
    compare :: URec Int p -> URec Int p -> Ordering
    $c< :: forall k (p :: k). URec Int p -> URec Int p -> Bool
    < :: URec Int p -> URec Int p -> Bool
    $c<= :: forall k (p :: k). URec Int p -> URec Int p -> Bool
    <= :: URec Int p -> URec Int p -> Bool
    $c> :: forall k (p :: k). URec Int p -> URec Int p -> Bool
    > :: URec Int p -> URec Int p -> Bool
    $c>= :: forall k (p :: k). URec Int p -> URec Int p -> Bool
    >= :: URec Int p -> URec Int p -> Bool
    $cmax :: forall k (p :: k). URec Int p -> URec Int p -> URec Int p
    max :: URec Int p -> URec Int p -> URec Int p
    $cmin :: forall k (p :: k). URec Int p -> URec Int p -> URec Int p
    min :: URec Int p -> URec Int p -> URec Int p
    Ord      -- ^ @since 4.9.0.0
               , Int -> URec Int p -> ShowS
    [URec Int p] -> ShowS
    URec Int p -> String
    (Int -> URec Int p -> ShowS)
    -> (URec Int p -> String)
    -> ([URec Int p] -> ShowS)
    -> Show (URec Int p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (p :: k). Int -> URec Int p -> ShowS
    forall k (p :: k). [URec Int p] -> ShowS
    forall k (p :: k). URec Int p -> String
    $cshowsPrec :: forall k (p :: k). Int -> URec Int p -> ShowS
    showsPrec :: Int -> URec Int p -> ShowS
    $cshow :: forall k (p :: k). URec Int p -> String
    show :: URec Int p -> String
    $cshowList :: forall k (p :: k). [URec Int p] -> ShowS
    showList :: [URec Int p] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , (forall a b. (a -> b) -> URec Int a -> URec Int b)
    -> (forall a b. a -> URec Int b -> URec Int a)
    -> Functor (URec Int)
    forall a b. a -> URec Int b -> URec Int a
    forall a b. (a -> b) -> URec Int a -> URec Int b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> URec Int a -> URec Int b
    fmap :: forall a b. (a -> b) -> URec Int a -> URec Int b
    $c<$ :: forall a b. a -> URec Int b -> URec Int a
    <$ :: forall a b. a -> URec Int b -> URec Int a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. URec Int p -> Rep (URec Int p) x)
    -> (forall x. Rep (URec Int p) x -> URec Int p)
    -> Generic (URec Int p)
    forall x. Rep (URec Int p) x -> URec Int p
    forall x. URec Int p -> Rep (URec Int p) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (p :: k) x. Rep (URec Int p) x -> URec Int p
    forall k (p :: k) x. URec Int p -> Rep (URec Int p) x
    $cfrom :: forall k (p :: k) x. URec Int p -> Rep (URec Int p) x
    from :: forall x. URec Int p -> Rep (URec Int p) x
    $cto :: forall k (p :: k) x. Rep (URec Int p) x -> URec Int p
    to :: forall x. Rep (URec Int p) x -> URec Int p
    Generic  -- ^ @since 4.9.0.0
               , (forall (a :: k). URec Int a -> Rep1 (URec Int) a)
    -> (forall (a :: k). Rep1 (URec Int) a -> URec Int a)
    -> Generic1 (URec Int)
    forall (a :: k). Rep1 (URec Int) a -> URec Int a
    forall (a :: k). URec Int a -> Rep1 (URec Int) a
    forall k (a :: k). Rep1 (URec Int) a -> URec Int a
    forall k (a :: k). URec Int a -> Rep1 (URec Int) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k (a :: k). URec Int a -> Rep1 (URec Int) a
    from1 :: forall (a :: k). URec Int a -> Rep1 (URec Int) a
    $cto1 :: forall k (a :: k). Rep1 (URec Int) a -> URec Int a
    to1 :: forall (a :: k). Rep1 (URec Int) a -> URec Int a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | Used for marking occurrences of 'Word#'
    --
    -- @since 4.9.0.0
    data instance URec Word (p :: k) = UWord { forall k (p :: k). URec Word p -> Word#
    uWord# :: Word# }
      deriving ( URec Word p -> URec Word p -> Bool
    (URec Word p -> URec Word p -> Bool)
    -> (URec Word p -> URec Word p -> Bool) -> Eq (URec Word p)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall k (p :: k). URec Word p -> URec Word p -> Bool
    $c== :: forall k (p :: k). URec Word p -> URec Word p -> Bool
    == :: URec Word p -> URec Word p -> Bool
    $c/= :: forall k (p :: k). URec Word p -> URec Word p -> Bool
    /= :: URec Word p -> URec Word p -> Bool
    Eq       -- ^ @since 4.9.0.0
               , Eq (URec Word p)
    Eq (URec Word p) =>
    (URec Word p -> URec Word p -> Ordering)
    -> (URec Word p -> URec Word p -> Bool)
    -> (URec Word p -> URec Word p -> Bool)
    -> (URec Word p -> URec Word p -> Bool)
    -> (URec Word p -> URec Word p -> Bool)
    -> (URec Word p -> URec Word p -> URec Word p)
    -> (URec Word p -> URec Word p -> URec Word p)
    -> Ord (URec Word p)
    URec Word p -> URec Word p -> Bool
    URec Word p -> URec Word p -> Ordering
    URec Word p -> URec Word p -> URec Word p
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall k (p :: k). Eq (URec Word p)
    forall k (p :: k). URec Word p -> URec Word p -> Bool
    forall k (p :: k). URec Word p -> URec Word p -> Ordering
    forall k (p :: k). URec Word p -> URec Word p -> URec Word p
    $ccompare :: forall k (p :: k). URec Word p -> URec Word p -> Ordering
    compare :: URec Word p -> URec Word p -> Ordering
    $c< :: forall k (p :: k). URec Word p -> URec Word p -> Bool
    < :: URec Word p -> URec Word p -> Bool
    $c<= :: forall k (p :: k). URec Word p -> URec Word p -> Bool
    <= :: URec Word p -> URec Word p -> Bool
    $c> :: forall k (p :: k). URec Word p -> URec Word p -> Bool
    > :: URec Word p -> URec Word p -> Bool
    $c>= :: forall k (p :: k). URec Word p -> URec Word p -> Bool
    >= :: URec Word p -> URec Word p -> Bool
    $cmax :: forall k (p :: k). URec Word p -> URec Word p -> URec Word p
    max :: URec Word p -> URec Word p -> URec Word p
    $cmin :: forall k (p :: k). URec Word p -> URec Word p -> URec Word p
    min :: URec Word p -> URec Word p -> URec Word p
    Ord      -- ^ @since 4.9.0.0
               , Int -> URec Word p -> ShowS
    [URec Word p] -> ShowS
    URec Word p -> String
    (Int -> URec Word p -> ShowS)
    -> (URec Word p -> String)
    -> ([URec Word p] -> ShowS)
    -> Show (URec Word p)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall k (p :: k). Int -> URec Word p -> ShowS
    forall k (p :: k). [URec Word p] -> ShowS
    forall k (p :: k). URec Word p -> String
    $cshowsPrec :: forall k (p :: k). Int -> URec Word p -> ShowS
    showsPrec :: Int -> URec Word p -> ShowS
    $cshow :: forall k (p :: k). URec Word p -> String
    show :: URec Word p -> String
    $cshowList :: forall k (p :: k). [URec Word p] -> ShowS
    showList :: [URec Word p] -> ShowS
    Show     -- ^ @since 4.9.0.0
               , (forall a b. (a -> b) -> URec Word a -> URec Word b)
    -> (forall a b. a -> URec Word b -> URec Word a)
    -> Functor (URec Word)
    forall a b. a -> URec Word b -> URec Word a
    forall a b. (a -> b) -> URec Word a -> URec Word b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall a b. (a -> b) -> URec Word a -> URec Word b
    fmap :: forall a b. (a -> b) -> URec Word a -> URec Word b
    $c<$ :: forall a b. a -> URec Word b -> URec Word a
    <$ :: forall a b. a -> URec Word b -> URec Word a
    Functor  -- ^ @since 4.9.0.0
               , (forall x. URec Word p -> Rep (URec Word p) x)
    -> (forall x. Rep (URec Word p) x -> URec Word p)
    -> Generic (URec Word p)
    forall x. Rep (URec Word p) x -> URec Word p
    forall x. URec Word p -> Rep (URec Word p) x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    forall k (p :: k) x. Rep (URec Word p) x -> URec Word p
    forall k (p :: k) x. URec Word p -> Rep (URec Word p) x
    $cfrom :: forall k (p :: k) x. URec Word p -> Rep (URec Word p) x
    from :: forall x. URec Word p -> Rep (URec Word p) x
    $cto :: forall k (p :: k) x. Rep (URec Word p) x -> URec Word p
    to :: forall x. Rep (URec Word p) x -> URec Word p
    Generic  -- ^ @since 4.9.0.0
               , (forall (a :: k). URec Word a -> Rep1 (URec Word) a)
    -> (forall (a :: k). Rep1 (URec Word) a -> URec Word a)
    -> Generic1 (URec Word)
    forall (a :: k). Rep1 (URec Word) a -> URec Word a
    forall (a :: k). URec Word a -> Rep1 (URec Word) a
    forall k (a :: k). Rep1 (URec Word) a -> URec Word a
    forall k (a :: k). URec Word a -> Rep1 (URec Word) a
    forall k (f :: k -> *).
    (forall (a :: k). f a -> Rep1 f a)
    -> (forall (a :: k). Rep1 f a -> f a) -> Generic1 f
    $cfrom1 :: forall k (a :: k). URec Word a -> Rep1 (URec Word) a
    from1 :: forall (a :: k). URec Word a -> Rep1 (URec Word) a
    $cto1 :: forall k (a :: k). Rep1 (URec Word) a -> URec Word a
    to1 :: forall (a :: k). Rep1 (URec Word) a -> URec Word a
    Generic1 -- ^ @since 4.9.0.0
               )

    -- | Type synonym for @'URec' 'Addr#'@
    --
    -- @since 4.9.0.0
    type UAddr   = URec (Ptr ())
    -- | Type synonym for @'URec' 'Char#'@
    --
    -- @since 4.9.0.0
    type UChar   = URec Char

    -- | Type synonym for @'URec' 'Double#'@
    --
    -- @since 4.9.0.0
    type UDouble = URec Double

    -- | Type synonym for @'URec' 'Float#'@
    --
    -- @since 4.9.0.0
    type UFloat  = URec Float

    -- | Type synonym for @'URec' 'Int#'@
    --
    -- @since 4.9.0.0
    type UInt    = URec Int

    -- | Type synonym for @'URec' 'Word#'@
    --
    -- @since 4.9.0.0
    type UWord   = URec Word

    -- | Tag for K1: recursion (of kind @Type@)
    data R

    -- | Type synonym for encoding recursion (of kind @Type@)
    type Rec0  = K1 R

    -- | Tag for M1: datatype
    data D
    -- | Tag for M1: constructor
    data C
    -- | Tag for M1: record selector
    data S

    -- | Type synonym for encoding meta-information for datatypes
    type D1 = M1 D

    -- | Type synonym for encoding meta-information for constructors
    type C1 = M1 C

    -- | Type synonym for encoding meta-information for record selectors
    type S1 = M1 S

    -- | Class for datatypes that represent datatypes
    class Datatype d where
      -- | The name of the datatype (unqualified)
      datatypeName :: t d (f :: k -> Type) (a :: k) -> [Char]
      -- | The fully-qualified name of the module where the type is declared
      moduleName   :: t d (f :: k -> Type) (a :: k) -> [Char]
      -- | The package name of the module where the type is declared
      --
      -- @since 4.9.0.0
      packageName :: t d (f :: k -> Type) (a :: k) -> [Char]
      -- | Marks if the datatype is actually a newtype
      --
      -- @since 4.7.0.0
      isNewtype    :: t d (f :: k -> Type) (a :: k) -> Bool
      isNewtype t d f a
    _ = Bool
    False

    -- | @since 4.9.0.0
    instance (KnownSymbol n, KnownSymbol m, KnownSymbol p, SingI nt)
        => Datatype ('MetaData n m p nt) where
      datatypeName :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaData n m p nt) f a -> String
    datatypeName t ('MetaData n m p nt) f a
    _ = Proxy n -> String
    forall (n :: Symbol) (proxy :: Symbol -> *).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy n
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy n)
      moduleName :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaData n m p nt) f a -> String
    moduleName   t ('MetaData n m p nt) f a
    _ = Proxy m -> String
    forall (n :: Symbol) (proxy :: Symbol -> *).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy m
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy m)
      packageName :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaData n m p nt) f a -> String
    packageName  t ('MetaData n m p nt) f a
    _ = Proxy p -> String
    forall (n :: Symbol) (proxy :: Symbol -> *).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy p
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy p)
      isNewtype :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaData n m p nt) f a -> Bool
    isNewtype    t ('MetaData n m p nt) f a
    _ = Sing nt -> DemoteRep Bool
    forall (a :: Bool). Sing a -> DemoteRep Bool
    forall k (a :: k). SingKind k => Sing a -> DemoteRep k
    fromSing  (Sing nt
    forall k (a :: k). SingI a => Sing a
    sing  :: Sing nt)

    -- | Class for datatypes that represent data constructors
    class Constructor c where
      -- | The name of the constructor
      conName :: t c (f :: k -> Type) (a :: k) -> [Char]

      -- | The fixity of the constructor
      conFixity :: t c (f :: k -> Type) (a :: k) -> Fixity
      conFixity t c f a
    _ = Fixity
    Prefix

      -- | Marks if this constructor is a record
      conIsRecord :: t c (f :: k -> Type) (a :: k) -> Bool
      conIsRecord t c f a
    _ = Bool
    False

    -- | @since 4.9.0.0
    instance (KnownSymbol n, SingI f, SingI r)
        => Constructor ('MetaCons n f r) where
      conName :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaCons n f r) f a -> String
    conName     t ('MetaCons n f r) f a
    _ = Proxy n -> String
    forall (n :: Symbol) (proxy :: Symbol -> *).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy n
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy n)
      conFixity :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaCons n f r) f a -> Fixity
    conFixity   t ('MetaCons n f r) f a
    _ = Sing f -> DemoteRep FixityI
    forall k (a :: k). SingKind k => Sing a -> DemoteRep k
    forall (a :: FixityI). Sing a -> DemoteRep FixityI
    fromSing  (Sing f
    forall k (a :: k). SingI a => Sing a
    sing  :: Sing f)
      conIsRecord :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaCons n f r) f a -> Bool
    conIsRecord t ('MetaCons n f r) f a
    _ = Sing r -> DemoteRep Bool
    forall (a :: Bool). Sing a -> DemoteRep Bool
    forall k (a :: k). SingKind k => Sing a -> DemoteRep k
    fromSing  (Sing r
    forall k (a :: k). SingI a => Sing a
    sing  :: Sing r)

    -- | Datatype to represent the fixity of a constructor. An infix
    -- | declaration directly corresponds to an application of 'Infix'.
    data Fixity = Prefix | Infix Associativity Int
      deriving ( Fixity -> Fixity -> Bool
    (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Bool) -> Eq Fixity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Fixity -> Fixity -> Bool
    == :: Fixity -> Fixity -> Bool
    $c/= :: Fixity -> Fixity -> Bool
    /= :: Fixity -> Fixity -> Bool
    Eq       -- ^ @since 4.6.0.0
               , Int -> Fixity -> ShowS
    [Fixity] -> ShowS
    Fixity -> String
    (Int -> Fixity -> ShowS)
    -> (Fixity -> String) -> ([Fixity] -> ShowS) -> Show Fixity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Fixity -> ShowS
    showsPrec :: Int -> Fixity -> ShowS
    $cshow :: Fixity -> String
    show :: Fixity -> String
    $cshowList :: [Fixity] -> ShowS
    showList :: [Fixity] -> ShowS
    Show     -- ^ @since 4.6.0.0
               , Eq Fixity
    Eq Fixity =>
    (Fixity -> Fixity -> Ordering)
    -> (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Bool)
    -> (Fixity -> Fixity -> Fixity)
    -> (Fixity -> Fixity -> Fixity)
    -> Ord Fixity
    Fixity -> Fixity -> Bool
    Fixity -> Fixity -> Ordering
    Fixity -> Fixity -> Fixity
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Fixity -> Fixity -> Ordering
    compare :: Fixity -> Fixity -> Ordering
    $c< :: Fixity -> Fixity -> Bool
    < :: Fixity -> Fixity -> Bool
    $c<= :: Fixity -> Fixity -> Bool
    <= :: Fixity -> Fixity -> Bool
    $c> :: Fixity -> Fixity -> Bool
    > :: Fixity -> Fixity -> Bool
    $c>= :: Fixity -> Fixity -> Bool
    >= :: Fixity -> Fixity -> Bool
    $cmax :: Fixity -> Fixity -> Fixity
    max :: Fixity -> Fixity -> Fixity
    $cmin :: Fixity -> Fixity -> Fixity
    min :: Fixity -> Fixity -> Fixity
    Ord      -- ^ @since 4.6.0.0
               , ReadPrec [Fixity]
    ReadPrec Fixity
    Int -> ReadS Fixity
    ReadS [Fixity]
    (Int -> ReadS Fixity)
    -> ReadS [Fixity]
    -> ReadPrec Fixity
    -> ReadPrec [Fixity]
    -> Read Fixity
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Fixity
    readsPrec :: Int -> ReadS Fixity
    $creadList :: ReadS [Fixity]
    readList :: ReadS [Fixity]
    $creadPrec :: ReadPrec Fixity
    readPrec :: ReadPrec Fixity
    $creadListPrec :: ReadPrec [Fixity]
    readListPrec :: ReadPrec [Fixity]
    Read     -- ^ @since 4.6.0.0
               , (forall x. Fixity -> Rep Fixity x)
    -> (forall x. Rep Fixity x -> Fixity) -> Generic Fixity
    forall x. Rep Fixity x -> Fixity
    forall x. Fixity -> Rep Fixity x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Fixity -> Rep Fixity x
    from :: forall x. Fixity -> Rep Fixity x
    $cto :: forall x. Rep Fixity x -> Fixity
    to :: forall x. Rep Fixity x -> Fixity
    Generic  -- ^ @since 4.7.0.0
               )

    -- | This variant of 'Fixity' appears at the type level.
    --
    -- @since 4.9.0.0
    data FixityI = PrefixI | InfixI Associativity Nat

    -- | Get the precedence of a fixity value.
    prec :: Fixity -> Int
    prec :: Fixity -> Int
    prec Fixity
    Prefix      = Int
    10
    prec (Infix Associativity
    _ Int
    n) = Int
    n

    -- | Datatype to represent the associativity of a constructor
    data Associativity = LeftAssociative
                       | RightAssociative
                       | NotAssociative
      deriving ( Associativity -> Associativity -> Bool
    (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Bool) -> Eq Associativity
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Associativity -> Associativity -> Bool
    == :: Associativity -> Associativity -> Bool
    $c/= :: Associativity -> Associativity -> Bool
    /= :: Associativity -> Associativity -> Bool
    Eq       -- ^ @since 4.6.0.0
               , Int -> Associativity -> ShowS
    [Associativity] -> ShowS
    Associativity -> String
    (Int -> Associativity -> ShowS)
    -> (Associativity -> String)
    -> ([Associativity] -> ShowS)
    -> Show Associativity
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Associativity -> ShowS
    showsPrec :: Int -> Associativity -> ShowS
    $cshow :: Associativity -> String
    show :: Associativity -> String
    $cshowList :: [Associativity] -> ShowS
    showList :: [Associativity] -> ShowS
    Show     -- ^ @since 4.6.0.0
               , Eq Associativity
    Eq Associativity =>
    (Associativity -> Associativity -> Ordering)
    -> (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Bool)
    -> (Associativity -> Associativity -> Associativity)
    -> (Associativity -> Associativity -> Associativity)
    -> Ord Associativity
    Associativity -> Associativity -> Bool
    Associativity -> Associativity -> Ordering
    Associativity -> Associativity -> Associativity
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: Associativity -> Associativity -> Ordering
    compare :: Associativity -> Associativity -> Ordering
    $c< :: Associativity -> Associativity -> Bool
    < :: Associativity -> Associativity -> Bool
    $c<= :: Associativity -> Associativity -> Bool
    <= :: Associativity -> Associativity -> Bool
    $c> :: Associativity -> Associativity -> Bool
    > :: Associativity -> Associativity -> Bool
    $c>= :: Associativity -> Associativity -> Bool
    >= :: Associativity -> Associativity -> Bool
    $cmax :: Associativity -> Associativity -> Associativity
    max :: Associativity -> Associativity -> Associativity
    $cmin :: Associativity -> Associativity -> Associativity
    min :: Associativity -> Associativity -> Associativity
    Ord      -- ^ @since 4.6.0.0
               , ReadPrec [Associativity]
    ReadPrec Associativity
    Int -> ReadS Associativity
    ReadS [Associativity]
    (Int -> ReadS Associativity)
    -> ReadS [Associativity]
    -> ReadPrec Associativity
    -> ReadPrec [Associativity]
    -> Read Associativity
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Associativity
    readsPrec :: Int -> ReadS Associativity
    $creadList :: ReadS [Associativity]
    readList :: ReadS [Associativity]
    $creadPrec :: ReadPrec Associativity
    readPrec :: ReadPrec Associativity
    $creadListPrec :: ReadPrec [Associativity]
    readListPrec :: ReadPrec [Associativity]
    Read     -- ^ @since 4.6.0.0
               , Int -> Associativity
    Associativity -> Int
    Associativity -> [Associativity]
    Associativity -> Associativity
    Associativity -> Associativity -> [Associativity]
    Associativity -> Associativity -> Associativity -> [Associativity]
    (Associativity -> Associativity)
    -> (Associativity -> Associativity)
    -> (Int -> Associativity)
    -> (Associativity -> Int)
    -> (Associativity -> [Associativity])
    -> (Associativity -> Associativity -> [Associativity])
    -> (Associativity -> Associativity -> [Associativity])
    -> (Associativity
        -> Associativity -> Associativity -> [Associativity])
    -> Enum Associativity
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: Associativity -> Associativity
    succ :: Associativity -> Associativity
    $cpred :: Associativity -> Associativity
    pred :: Associativity -> Associativity
    $ctoEnum :: Int -> Associativity
    toEnum :: Int -> Associativity
    $cfromEnum :: Associativity -> Int
    fromEnum :: Associativity -> Int
    $cenumFrom :: Associativity -> [Associativity]
    enumFrom :: Associativity -> [Associativity]
    $cenumFromThen :: Associativity -> Associativity -> [Associativity]
    enumFromThen :: Associativity -> Associativity -> [Associativity]
    $cenumFromTo :: Associativity -> Associativity -> [Associativity]
    enumFromTo :: Associativity -> Associativity -> [Associativity]
    $cenumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity]
    enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity]
    Enum     -- ^ @since 4.9.0.0
               , Associativity
    Associativity -> Associativity -> Bounded Associativity
    forall a. a -> a -> Bounded a
    $cminBound :: Associativity
    minBound :: Associativity
    $cmaxBound :: Associativity
    maxBound :: Associativity
    Bounded  -- ^ @since 4.9.0.0
               , Ord Associativity
    Ord Associativity =>
    ((Associativity, Associativity) -> [Associativity])
    -> ((Associativity, Associativity) -> Associativity -> Int)
    -> ((Associativity, Associativity) -> Associativity -> Int)
    -> ((Associativity, Associativity) -> Associativity -> Bool)
    -> ((Associativity, Associativity) -> Int)
    -> ((Associativity, Associativity) -> Int)
    -> Ix Associativity
    (Associativity, Associativity) -> Int
    (Associativity, Associativity) -> [Associativity]
    (Associativity, Associativity) -> Associativity -> Bool
    (Associativity, Associativity) -> Associativity -> Int
    forall a.
    Ord a =>
    ((a, a) -> [a])
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Bool)
    -> ((a, a) -> Int)
    -> ((a, a) -> Int)
    -> Ix a
    $crange :: (Associativity, Associativity) -> [Associativity]
    range :: (Associativity, Associativity) -> [Associativity]
    $cindex :: (Associativity, Associativity) -> Associativity -> Int
    index :: (Associativity, Associativity) -> Associativity -> Int
    $cunsafeIndex :: (Associativity, Associativity) -> Associativity -> Int
    unsafeIndex :: (Associativity, Associativity) -> Associativity -> Int
    $cinRange :: (Associativity, Associativity) -> Associativity -> Bool
    inRange :: (Associativity, Associativity) -> Associativity -> Bool
    $crangeSize :: (Associativity, Associativity) -> Int
    rangeSize :: (Associativity, Associativity) -> Int
    $cunsafeRangeSize :: (Associativity, Associativity) -> Int
    unsafeRangeSize :: (Associativity, Associativity) -> Int
    Ix       -- ^ @since 4.9.0.0
               , (forall x. Associativity -> Rep Associativity x)
    -> (forall x. Rep Associativity x -> Associativity)
    -> Generic Associativity
    forall x. Rep Associativity x -> Associativity
    forall x. Associativity -> Rep Associativity x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. Associativity -> Rep Associativity x
    from :: forall x. Associativity -> Rep Associativity x
    $cto :: forall x. Rep Associativity x -> Associativity
    to :: forall x. Rep Associativity x -> Associativity
    Generic  -- ^ @since 4.7.0.0
               )

    -- | 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 4.9.0.0
    data SourceUnpackedness = NoSourceUnpackedness
                            | SourceNoUnpack
                            | SourceUnpack
      deriving ( SourceUnpackedness -> SourceUnpackedness -> Bool
    (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> Eq SourceUnpackedness
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SourceUnpackedness -> SourceUnpackedness -> Bool
    == :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c/= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    /= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    Eq      -- ^ @since 4.9.0.0
               , Int -> SourceUnpackedness -> ShowS
    [SourceUnpackedness] -> ShowS
    SourceUnpackedness -> String
    (Int -> SourceUnpackedness -> ShowS)
    -> (SourceUnpackedness -> String)
    -> ([SourceUnpackedness] -> ShowS)
    -> Show SourceUnpackedness
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SourceUnpackedness -> ShowS
    showsPrec :: Int -> SourceUnpackedness -> ShowS
    $cshow :: SourceUnpackedness -> String
    show :: SourceUnpackedness -> String
    $cshowList :: [SourceUnpackedness] -> ShowS
    showList :: [SourceUnpackedness] -> ShowS
    Show    -- ^ @since 4.9.0.0
               , Eq SourceUnpackedness
    Eq SourceUnpackedness =>
    (SourceUnpackedness -> SourceUnpackedness -> Ordering)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> Bool)
    -> (SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness)
    -> (SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness)
    -> Ord SourceUnpackedness
    SourceUnpackedness -> SourceUnpackedness -> Bool
    SourceUnpackedness -> SourceUnpackedness -> Ordering
    SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: SourceUnpackedness -> SourceUnpackedness -> Ordering
    compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering
    $c< :: SourceUnpackedness -> SourceUnpackedness -> Bool
    < :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c<= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    <= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c> :: SourceUnpackedness -> SourceUnpackedness -> Bool
    > :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $c>= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    >= :: SourceUnpackedness -> SourceUnpackedness -> Bool
    $cmax :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    $cmin :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness
    Ord     -- ^ @since 4.9.0.0
               , ReadPrec [SourceUnpackedness]
    ReadPrec SourceUnpackedness
    Int -> ReadS SourceUnpackedness
    ReadS [SourceUnpackedness]
    (Int -> ReadS SourceUnpackedness)
    -> ReadS [SourceUnpackedness]
    -> ReadPrec SourceUnpackedness
    -> ReadPrec [SourceUnpackedness]
    -> Read SourceUnpackedness
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS SourceUnpackedness
    readsPrec :: Int -> ReadS SourceUnpackedness
    $creadList :: ReadS [SourceUnpackedness]
    readList :: ReadS [SourceUnpackedness]
    $creadPrec :: ReadPrec SourceUnpackedness
    readPrec :: ReadPrec SourceUnpackedness
    $creadListPrec :: ReadPrec [SourceUnpackedness]
    readListPrec :: ReadPrec [SourceUnpackedness]
    Read    -- ^ @since 4.9.0.0
               , Int -> SourceUnpackedness
    SourceUnpackedness -> Int
    SourceUnpackedness -> [SourceUnpackedness]
    SourceUnpackedness -> SourceUnpackedness
    SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]
    SourceUnpackedness
    -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]
    (SourceUnpackedness -> SourceUnpackedness)
    -> (SourceUnpackedness -> SourceUnpackedness)
    -> (Int -> SourceUnpackedness)
    -> (SourceUnpackedness -> Int)
    -> (SourceUnpackedness -> [SourceUnpackedness])
    -> (SourceUnpackedness
        -> SourceUnpackedness -> [SourceUnpackedness])
    -> (SourceUnpackedness
        -> SourceUnpackedness -> [SourceUnpackedness])
    -> (SourceUnpackedness
        -> SourceUnpackedness
        -> SourceUnpackedness
        -> [SourceUnpackedness])
    -> Enum SourceUnpackedness
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: SourceUnpackedness -> SourceUnpackedness
    succ :: SourceUnpackedness -> SourceUnpackedness
    $cpred :: SourceUnpackedness -> SourceUnpackedness
    pred :: SourceUnpackedness -> SourceUnpackedness
    $ctoEnum :: Int -> SourceUnpackedness
    toEnum :: Int -> SourceUnpackedness
    $cfromEnum :: SourceUnpackedness -> Int
    fromEnum :: SourceUnpackedness -> Int
    $cenumFrom :: SourceUnpackedness -> [SourceUnpackedness]
    enumFrom :: SourceUnpackedness -> [SourceUnpackedness]
    $cenumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]
    enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]
    $cenumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]
    enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]
    $cenumFromThenTo :: SourceUnpackedness
    -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]
    enumFromThenTo :: SourceUnpackedness
    -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness]
    Enum    -- ^ @since 4.9.0.0
               , SourceUnpackedness
    SourceUnpackedness
    -> SourceUnpackedness -> Bounded SourceUnpackedness
    forall a. a -> a -> Bounded a
    $cminBound :: SourceUnpackedness
    minBound :: SourceUnpackedness
    $cmaxBound :: SourceUnpackedness
    maxBound :: SourceUnpackedness
    Bounded -- ^ @since 4.9.0.0
               , Ord SourceUnpackedness
    Ord SourceUnpackedness =>
    ((SourceUnpackedness, SourceUnpackedness) -> [SourceUnpackedness])
    -> ((SourceUnpackedness, SourceUnpackedness)
        -> SourceUnpackedness -> Int)
    -> ((SourceUnpackedness, SourceUnpackedness)
        -> SourceUnpackedness -> Int)
    -> ((SourceUnpackedness, SourceUnpackedness)
        -> SourceUnpackedness -> Bool)
    -> ((SourceUnpackedness, SourceUnpackedness) -> Int)
    -> ((SourceUnpackedness, SourceUnpackedness) -> Int)
    -> Ix SourceUnpackedness
    (SourceUnpackedness, SourceUnpackedness) -> Int
    (SourceUnpackedness, SourceUnpackedness) -> [SourceUnpackedness]
    (SourceUnpackedness, SourceUnpackedness)
    -> SourceUnpackedness -> Bool
    (SourceUnpackedness, SourceUnpackedness)
    -> SourceUnpackedness -> Int
    forall a.
    Ord a =>
    ((a, a) -> [a])
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Bool)
    -> ((a, a) -> Int)
    -> ((a, a) -> Int)
    -> Ix a
    $crange :: (SourceUnpackedness, SourceUnpackedness) -> [SourceUnpackedness]
    range :: (SourceUnpackedness, SourceUnpackedness) -> [SourceUnpackedness]
    $cindex :: (SourceUnpackedness, SourceUnpackedness)
    -> SourceUnpackedness -> Int
    index :: (SourceUnpackedness, SourceUnpackedness)
    -> SourceUnpackedness -> Int
    $cunsafeIndex :: (SourceUnpackedness, SourceUnpackedness)
    -> SourceUnpackedness -> Int
    unsafeIndex :: (SourceUnpackedness, SourceUnpackedness)
    -> SourceUnpackedness -> Int
    $cinRange :: (SourceUnpackedness, SourceUnpackedness)
    -> SourceUnpackedness -> Bool
    inRange :: (SourceUnpackedness, SourceUnpackedness)
    -> SourceUnpackedness -> Bool
    $crangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int
    rangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int
    $cunsafeRangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int
    unsafeRangeSize :: (SourceUnpackedness, SourceUnpackedness) -> Int
    Ix      -- ^ @since 4.9.0.0
               , (forall x. SourceUnpackedness -> Rep SourceUnpackedness x)
    -> (forall x. Rep SourceUnpackedness x -> SourceUnpackedness)
    -> Generic SourceUnpackedness
    forall x. Rep SourceUnpackedness x -> SourceUnpackedness
    forall x. SourceUnpackedness -> Rep SourceUnpackedness x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. SourceUnpackedness -> Rep SourceUnpackedness x
    from :: forall x. SourceUnpackedness -> Rep SourceUnpackedness x
    $cto :: forall x. Rep SourceUnpackedness x -> SourceUnpackedness
    to :: forall x. Rep SourceUnpackedness x -> SourceUnpackedness
    Generic -- ^ @since 4.9.0.0
               )

    -- | 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 4.9.0.0
    data SourceStrictness = NoSourceStrictness
                          | SourceLazy
                          | SourceStrict
      deriving ( SourceStrictness -> SourceStrictness -> Bool
    (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> Eq SourceStrictness
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SourceStrictness -> SourceStrictness -> Bool
    == :: SourceStrictness -> SourceStrictness -> Bool
    $c/= :: SourceStrictness -> SourceStrictness -> Bool
    /= :: SourceStrictness -> SourceStrictness -> Bool
    Eq      -- ^ @since 4.9.0.0
               , Int -> SourceStrictness -> ShowS
    [SourceStrictness] -> ShowS
    SourceStrictness -> String
    (Int -> SourceStrictness -> ShowS)
    -> (SourceStrictness -> String)
    -> ([SourceStrictness] -> ShowS)
    -> Show SourceStrictness
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SourceStrictness -> ShowS
    showsPrec :: Int -> SourceStrictness -> ShowS
    $cshow :: SourceStrictness -> String
    show :: SourceStrictness -> String
    $cshowList :: [SourceStrictness] -> ShowS
    showList :: [SourceStrictness] -> ShowS
    Show    -- ^ @since 4.9.0.0
               , Eq SourceStrictness
    Eq SourceStrictness =>
    (SourceStrictness -> SourceStrictness -> Ordering)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> Bool)
    -> (SourceStrictness -> SourceStrictness -> SourceStrictness)
    -> (SourceStrictness -> SourceStrictness -> SourceStrictness)
    -> Ord SourceStrictness
    SourceStrictness -> SourceStrictness -> Bool
    SourceStrictness -> SourceStrictness -> Ordering
    SourceStrictness -> SourceStrictness -> SourceStrictness
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: SourceStrictness -> SourceStrictness -> Ordering
    compare :: SourceStrictness -> SourceStrictness -> Ordering
    $c< :: SourceStrictness -> SourceStrictness -> Bool
    < :: SourceStrictness -> SourceStrictness -> Bool
    $c<= :: SourceStrictness -> SourceStrictness -> Bool
    <= :: SourceStrictness -> SourceStrictness -> Bool
    $c> :: SourceStrictness -> SourceStrictness -> Bool
    > :: SourceStrictness -> SourceStrictness -> Bool
    $c>= :: SourceStrictness -> SourceStrictness -> Bool
    >= :: SourceStrictness -> SourceStrictness -> Bool
    $cmax :: SourceStrictness -> SourceStrictness -> SourceStrictness
    max :: SourceStrictness -> SourceStrictness -> SourceStrictness
    $cmin :: SourceStrictness -> SourceStrictness -> SourceStrictness
    min :: SourceStrictness -> SourceStrictness -> SourceStrictness
    Ord     -- ^ @since 4.9.0.0
               , ReadPrec [SourceStrictness]
    ReadPrec SourceStrictness
    Int -> ReadS SourceStrictness
    ReadS [SourceStrictness]
    (Int -> ReadS SourceStrictness)
    -> ReadS [SourceStrictness]
    -> ReadPrec SourceStrictness
    -> ReadPrec [SourceStrictness]
    -> Read SourceStrictness
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS SourceStrictness
    readsPrec :: Int -> ReadS SourceStrictness
    $creadList :: ReadS [SourceStrictness]
    readList :: ReadS [SourceStrictness]
    $creadPrec :: ReadPrec SourceStrictness
    readPrec :: ReadPrec SourceStrictness
    $creadListPrec :: ReadPrec [SourceStrictness]
    readListPrec :: ReadPrec [SourceStrictness]
    Read    -- ^ @since 4.9.0.0
               , Int -> SourceStrictness
    SourceStrictness -> Int
    SourceStrictness -> [SourceStrictness]
    SourceStrictness -> SourceStrictness
    SourceStrictness -> SourceStrictness -> [SourceStrictness]
    SourceStrictness
    -> SourceStrictness -> SourceStrictness -> [SourceStrictness]
    (SourceStrictness -> SourceStrictness)
    -> (SourceStrictness -> SourceStrictness)
    -> (Int -> SourceStrictness)
    -> (SourceStrictness -> Int)
    -> (SourceStrictness -> [SourceStrictness])
    -> (SourceStrictness -> SourceStrictness -> [SourceStrictness])
    -> (SourceStrictness -> SourceStrictness -> [SourceStrictness])
    -> (SourceStrictness
        -> SourceStrictness -> SourceStrictness -> [SourceStrictness])
    -> Enum SourceStrictness
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: SourceStrictness -> SourceStrictness
    succ :: SourceStrictness -> SourceStrictness
    $cpred :: SourceStrictness -> SourceStrictness
    pred :: SourceStrictness -> SourceStrictness
    $ctoEnum :: Int -> SourceStrictness
    toEnum :: Int -> SourceStrictness
    $cfromEnum :: SourceStrictness -> Int
    fromEnum :: SourceStrictness -> Int
    $cenumFrom :: SourceStrictness -> [SourceStrictness]
    enumFrom :: SourceStrictness -> [SourceStrictness]
    $cenumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness]
    enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness]
    $cenumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness]
    enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness]
    $cenumFromThenTo :: SourceStrictness
    -> SourceStrictness -> SourceStrictness -> [SourceStrictness]
    enumFromThenTo :: SourceStrictness
    -> SourceStrictness -> SourceStrictness -> [SourceStrictness]
    Enum    -- ^ @since 4.9.0.0
               , SourceStrictness
    SourceStrictness -> SourceStrictness -> Bounded SourceStrictness
    forall a. a -> a -> Bounded a
    $cminBound :: SourceStrictness
    minBound :: SourceStrictness
    $cmaxBound :: SourceStrictness
    maxBound :: SourceStrictness
    Bounded -- ^ @since 4.9.0.0
               , Ord SourceStrictness
    Ord SourceStrictness =>
    ((SourceStrictness, SourceStrictness) -> [SourceStrictness])
    -> ((SourceStrictness, SourceStrictness)
        -> SourceStrictness -> Int)
    -> ((SourceStrictness, SourceStrictness)
        -> SourceStrictness -> Int)
    -> ((SourceStrictness, SourceStrictness)
        -> SourceStrictness -> Bool)
    -> ((SourceStrictness, SourceStrictness) -> Int)
    -> ((SourceStrictness, SourceStrictness) -> Int)
    -> Ix SourceStrictness
    (SourceStrictness, SourceStrictness) -> Int
    (SourceStrictness, SourceStrictness) -> [SourceStrictness]
    (SourceStrictness, SourceStrictness) -> SourceStrictness -> Bool
    (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int
    forall a.
    Ord a =>
    ((a, a) -> [a])
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Bool)
    -> ((a, a) -> Int)
    -> ((a, a) -> Int)
    -> Ix a
    $crange :: (SourceStrictness, SourceStrictness) -> [SourceStrictness]
    range :: (SourceStrictness, SourceStrictness) -> [SourceStrictness]
    $cindex :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int
    index :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int
    $cunsafeIndex :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int
    unsafeIndex :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Int
    $cinRange :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Bool
    inRange :: (SourceStrictness, SourceStrictness) -> SourceStrictness -> Bool
    $crangeSize :: (SourceStrictness, SourceStrictness) -> Int
    rangeSize :: (SourceStrictness, SourceStrictness) -> Int
    $cunsafeRangeSize :: (SourceStrictness, SourceStrictness) -> Int
    unsafeRangeSize :: (SourceStrictness, SourceStrictness) -> Int
    Ix      -- ^ @since 4.9.0.0
               , (forall x. SourceStrictness -> Rep SourceStrictness x)
    -> (forall x. Rep SourceStrictness x -> SourceStrictness)
    -> Generic SourceStrictness
    forall x. Rep SourceStrictness x -> SourceStrictness
    forall x. SourceStrictness -> Rep SourceStrictness x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. SourceStrictness -> Rep SourceStrictness x
    from :: forall x. SourceStrictness -> Rep SourceStrictness x
    $cto :: forall x. Rep SourceStrictness x -> SourceStrictness
    to :: forall x. Rep SourceStrictness x -> SourceStrictness
    Generic -- ^ @since 4.9.0.0
               )

    -- | 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 4.9.0.0
    data DecidedStrictness = DecidedLazy
                           | DecidedStrict
                           | DecidedUnpack
      deriving ( DecidedStrictness -> DecidedStrictness -> Bool
    (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> Eq DecidedStrictness
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DecidedStrictness -> DecidedStrictness -> Bool
    == :: DecidedStrictness -> DecidedStrictness -> Bool
    $c/= :: DecidedStrictness -> DecidedStrictness -> Bool
    /= :: DecidedStrictness -> DecidedStrictness -> Bool
    Eq      -- ^ @since 4.9.0.0
               , Int -> DecidedStrictness -> ShowS
    [DecidedStrictness] -> ShowS
    DecidedStrictness -> String
    (Int -> DecidedStrictness -> ShowS)
    -> (DecidedStrictness -> String)
    -> ([DecidedStrictness] -> ShowS)
    -> Show DecidedStrictness
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DecidedStrictness -> ShowS
    showsPrec :: Int -> DecidedStrictness -> ShowS
    $cshow :: DecidedStrictness -> String
    show :: DecidedStrictness -> String
    $cshowList :: [DecidedStrictness] -> ShowS
    showList :: [DecidedStrictness] -> ShowS
    Show    -- ^ @since 4.9.0.0
               , Eq DecidedStrictness
    Eq DecidedStrictness =>
    (DecidedStrictness -> DecidedStrictness -> Ordering)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> Bool)
    -> (DecidedStrictness -> DecidedStrictness -> DecidedStrictness)
    -> (DecidedStrictness -> DecidedStrictness -> DecidedStrictness)
    -> Ord DecidedStrictness
    DecidedStrictness -> DecidedStrictness -> Bool
    DecidedStrictness -> DecidedStrictness -> Ordering
    DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: DecidedStrictness -> DecidedStrictness -> Ordering
    compare :: DecidedStrictness -> DecidedStrictness -> Ordering
    $c< :: DecidedStrictness -> DecidedStrictness -> Bool
    < :: DecidedStrictness -> DecidedStrictness -> Bool
    $c<= :: DecidedStrictness -> DecidedStrictness -> Bool
    <= :: DecidedStrictness -> DecidedStrictness -> Bool
    $c> :: DecidedStrictness -> DecidedStrictness -> Bool
    > :: DecidedStrictness -> DecidedStrictness -> Bool
    $c>= :: DecidedStrictness -> DecidedStrictness -> Bool
    >= :: DecidedStrictness -> DecidedStrictness -> Bool
    $cmax :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    $cmin :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness
    Ord     -- ^ @since 4.9.0.0
               , ReadPrec [DecidedStrictness]
    ReadPrec DecidedStrictness
    Int -> ReadS DecidedStrictness
    ReadS [DecidedStrictness]
    (Int -> ReadS DecidedStrictness)
    -> ReadS [DecidedStrictness]
    -> ReadPrec DecidedStrictness
    -> ReadPrec [DecidedStrictness]
    -> Read DecidedStrictness
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS DecidedStrictness
    readsPrec :: Int -> ReadS DecidedStrictness
    $creadList :: ReadS [DecidedStrictness]
    readList :: ReadS [DecidedStrictness]
    $creadPrec :: ReadPrec DecidedStrictness
    readPrec :: ReadPrec DecidedStrictness
    $creadListPrec :: ReadPrec [DecidedStrictness]
    readListPrec :: ReadPrec [DecidedStrictness]
    Read    -- ^ @since 4.9.0.0
               , Int -> DecidedStrictness
    DecidedStrictness -> Int
    DecidedStrictness -> [DecidedStrictness]
    DecidedStrictness -> DecidedStrictness
    DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]
    DecidedStrictness
    -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]
    (DecidedStrictness -> DecidedStrictness)
    -> (DecidedStrictness -> DecidedStrictness)
    -> (Int -> DecidedStrictness)
    -> (DecidedStrictness -> Int)
    -> (DecidedStrictness -> [DecidedStrictness])
    -> (DecidedStrictness -> DecidedStrictness -> [DecidedStrictness])
    -> (DecidedStrictness -> DecidedStrictness -> [DecidedStrictness])
    -> (DecidedStrictness
        -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness])
    -> Enum DecidedStrictness
    forall a.
    (a -> a)
    -> (a -> a)
    -> (Int -> a)
    -> (a -> Int)
    -> (a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> [a])
    -> (a -> a -> a -> [a])
    -> Enum a
    $csucc :: DecidedStrictness -> DecidedStrictness
    succ :: DecidedStrictness -> DecidedStrictness
    $cpred :: DecidedStrictness -> DecidedStrictness
    pred :: DecidedStrictness -> DecidedStrictness
    $ctoEnum :: Int -> DecidedStrictness
    toEnum :: Int -> DecidedStrictness
    $cfromEnum :: DecidedStrictness -> Int
    fromEnum :: DecidedStrictness -> Int
    $cenumFrom :: DecidedStrictness -> [DecidedStrictness]
    enumFrom :: DecidedStrictness -> [DecidedStrictness]
    $cenumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]
    enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]
    $cenumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]
    enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]
    $cenumFromThenTo :: DecidedStrictness
    -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]
    enumFromThenTo :: DecidedStrictness
    -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness]
    Enum    -- ^ @since 4.9.0.0
               , DecidedStrictness
    DecidedStrictness -> DecidedStrictness -> Bounded DecidedStrictness
    forall a. a -> a -> Bounded a
    $cminBound :: DecidedStrictness
    minBound :: DecidedStrictness
    $cmaxBound :: DecidedStrictness
    maxBound :: DecidedStrictness
    Bounded -- ^ @since 4.9.0.0
               , Ord DecidedStrictness
    Ord DecidedStrictness =>
    ((DecidedStrictness, DecidedStrictness) -> [DecidedStrictness])
    -> ((DecidedStrictness, DecidedStrictness)
        -> DecidedStrictness -> Int)
    -> ((DecidedStrictness, DecidedStrictness)
        -> DecidedStrictness -> Int)
    -> ((DecidedStrictness, DecidedStrictness)
        -> DecidedStrictness -> Bool)
    -> ((DecidedStrictness, DecidedStrictness) -> Int)
    -> ((DecidedStrictness, DecidedStrictness) -> Int)
    -> Ix DecidedStrictness
    (DecidedStrictness, DecidedStrictness) -> Int
    (DecidedStrictness, DecidedStrictness) -> [DecidedStrictness]
    (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Bool
    (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int
    forall a.
    Ord a =>
    ((a, a) -> [a])
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Int)
    -> ((a, a) -> a -> Bool)
    -> ((a, a) -> Int)
    -> ((a, a) -> Int)
    -> Ix a
    $crange :: (DecidedStrictness, DecidedStrictness) -> [DecidedStrictness]
    range :: (DecidedStrictness, DecidedStrictness) -> [DecidedStrictness]
    $cindex :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int
    index :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int
    $cunsafeIndex :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int
    unsafeIndex :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Int
    $cinRange :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Bool
    inRange :: (DecidedStrictness, DecidedStrictness) -> DecidedStrictness -> Bool
    $crangeSize :: (DecidedStrictness, DecidedStrictness) -> Int
    rangeSize :: (DecidedStrictness, DecidedStrictness) -> Int
    $cunsafeRangeSize :: (DecidedStrictness, DecidedStrictness) -> Int
    unsafeRangeSize :: (DecidedStrictness, DecidedStrictness) -> Int
    Ix      -- ^ @since 4.9.0.0
               , (forall x. DecidedStrictness -> Rep DecidedStrictness x)
    -> (forall x. Rep DecidedStrictness x -> DecidedStrictness)
    -> Generic DecidedStrictness
    forall x. Rep DecidedStrictness x -> DecidedStrictness
    forall x. DecidedStrictness -> Rep DecidedStrictness x
    forall a.
    (forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
    $cfrom :: forall x. DecidedStrictness -> Rep DecidedStrictness x
    from :: forall x. DecidedStrictness -> Rep DecidedStrictness x
    $cto :: forall x. Rep DecidedStrictness x -> DecidedStrictness
    to :: forall x. Rep DecidedStrictness x -> DecidedStrictness
    Generic -- ^ @since 4.9.0.0
               )

    -- | Class for datatypes that represent records
    class Selector s where
      -- | The name of the selector
      selName :: t s (f :: k -> Type) (a :: k) -> [Char]
      -- | The selector's unpackedness annotation (if any)
      --
      -- @since 4.9.0.0
      selSourceUnpackedness :: t s (f :: k -> Type) (a :: k) -> SourceUnpackedness
      -- | The selector's strictness annotation (if any)
      --
      -- @since 4.9.0.0
      selSourceStrictness :: t s (f :: k -> Type) (a :: k) -> SourceStrictness
      -- | The strictness that the compiler inferred for the selector
      --
      -- @since 4.9.0.0
      selDecidedStrictness :: t s (f :: k -> Type) (a :: k) -> DecidedStrictness

    -- | @since 4.9.0.0
    instance (SingI mn, SingI su, SingI ss, SingI ds)
        => Selector ('MetaSel mn su ss ds) where
      selName :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaSel mn su ss ds) f a -> String
    selName t ('MetaSel mn su ss ds) f a
    _ = String -> Maybe String -> String
    forall a. a -> Maybe a -> a
    fromMaybe String
    "" (Sing mn -> DemoteRep (Maybe Symbol)
    forall (a :: Maybe Symbol). Sing a -> DemoteRep (Maybe Symbol)
    forall k (a :: k). SingKind k => Sing a -> DemoteRep k
    fromSing (Sing mn
    forall k (a :: k). SingI a => Sing a
    sing :: Sing mn))
      selSourceUnpackedness :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaSel mn su ss ds) f a -> SourceUnpackedness
    selSourceUnpackedness t ('MetaSel mn su ss ds) f a
    _ = Sing su -> DemoteRep SourceUnpackedness
    forall k (a :: k). SingKind k => Sing a -> DemoteRep k
    forall (a :: SourceUnpackedness).
    Sing a -> DemoteRep SourceUnpackedness
    fromSing (Sing su
    forall k (a :: k). SingI a => Sing a
    sing :: Sing su)
      selSourceStrictness :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaSel mn su ss ds) f a -> SourceStrictness
    selSourceStrictness   t ('MetaSel mn su ss ds) f a
    _ = Sing ss -> DemoteRep SourceStrictness
    forall k (a :: k). SingKind k => Sing a -> DemoteRep k
    forall (a :: SourceStrictness).
    Sing a -> DemoteRep SourceStrictness
    fromSing (Sing ss
    forall k (a :: k). SingI a => Sing a
    sing :: Sing ss)
      selDecidedStrictness :: forall k (t :: Meta -> (k -> *) -> k -> *) (f :: k -> *) (a :: k).
    t ('MetaSel mn su ss ds) f a -> DecidedStrictness
    selDecidedStrictness  t ('MetaSel mn su ss ds) f a
    _ = Sing ds -> DemoteRep DecidedStrictness
    forall k (a :: k). SingKind k => Sing a -> DemoteRep k
    forall (a :: DecidedStrictness).
    Sing a -> DemoteRep DecidedStrictness
    fromSing (Sing ds
    forall k (a :: k). SingI a => Sing a
    sing :: Sing ds)

    -- | 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' ≡ 'Prelude.id'
    -- 'to' . 'from' ≡ 'Prelude.id'
    -- @
    class Generic a where
      -- | Generic representation type
      type Rep a :: Type -> Type
      -- | Convert from the datatype to its representation
      from  :: a -> (Rep a) x
      -- | Convert from the representation to the datatype
      to    :: (Rep a) x -> a

    -- | 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' ≡ 'Prelude.id'
    -- 'to1' . 'from1' ≡ 'Prelude.id'
    -- @
    class Generic1 (f :: k -> Type) where
      -- | Generic representation type
      type Rep1 f :: k -> Type
      -- | Convert from the datatype to its representation
      from1  :: f a -> (Rep1 f) a
      -- | Convert from the representation to the datatype
      to1    :: (Rep1 f) a -> f a

    --------------------------------------------------------------------------------
    -- 'Generic' wrapper
    --------------------------------------------------------------------------------

    -- | A datatype whose instances are defined generically, using the
    -- 'Generic' representation. 'Generically1' is a higher-kinded version
    -- of 'Generically' that uses 'Generic1'.
    --
    -- Generic instances can be derived via @'Generically' A@ using
    -- @-XDerivingVia@.
    --
    -- @
    -- {-# LANGUAGE DeriveGeneric      #-}
    -- {-# LANGUAGE DerivingStrategies #-}
    -- {-# LANGUAGE DerivingVia        #-}
    --
    -- import GHC.Generics (Generic)
    --
    -- data V4 a = V4 a a a a
    --   deriving stock Generic
    --
    --   deriving (Semigroup, Monoid)
    --   via Generically (V4 a)
    -- @
    --
    -- This corresponds to 'Semigroup' and 'Monoid' instances defined by
    -- pointwise lifting:
    --
    -- @
    -- instance Semigroup a => Semigroup (V4 a) where
    --   (<>) :: V4 a -> V4 a -> V4 a
    --   V4 a1 b1 c1 d1 <> V4 a2 b2 c2 d2 =
    --     V4 (a1 <> a2) (b1 <> b2) (c1 <> c2) (d1 <> d2)
    --
    -- instance Monoid a => Monoid (V4 a) where
    --   mempty :: V4 a
    --   mempty = V4 mempty mempty mempty mempty
    -- @
    --
    -- Historically this required modifying the type class to include
    -- generic method definitions (@-XDefaultSignatures@) and deriving it
    -- with the @anyclass@ strategy (@-XDeriveAnyClass@). Having a /via
    -- type/ like 'Generically' decouples the instance from the type
    -- class.
    --
    -- @since 4.17.0.0
    newtype Generically a = Generically a

    -- | @since 4.17.0.0
    instance (Generic a, Semigroup (Rep a ())) => Semigroup (Generically a) where
      (<>) :: Generically a -> Generically a -> Generically a
      Generically a
    a <> :: Generically a -> Generically a -> Generically a
    <> Generically a
    b = a -> Generically a
    forall a. a -> Generically a
    Generically (Rep a () -> a
    forall a x. Generic a => Rep a x -> a
    forall x. Rep a x -> a
    to (a -> Rep a ()
    forall x. a -> Rep a x
    forall a x. Generic a => a -> Rep a x
    from a
    a Rep a () -> Rep a () -> Rep a ()
    forall a. Semigroup a => a -> a -> a
    <> a -> Rep a ()
    forall x. a -> Rep a x
    forall a x. Generic a => a -> Rep a x
    from a
    b :: Rep a ()))

    -- | @since 4.17.0.0
    instance (Generic a, Monoid (Rep a ())) => Monoid (Generically a) where
      mempty :: Generically a
      mempty :: Generically a
    mempty = a -> Generically a
    forall a. a -> Generically a
    Generically (Rep a () -> a
    forall a x. Generic a => Rep a x -> a
    forall x. Rep a x -> a
    to (Rep a ()
    forall a. Monoid a => a
    mempty :: Rep a ()))

      mappend :: Generically a -> Generically a -> Generically a
      mappend :: Generically a -> Generically a -> Generically a
    mappend = Generically a -> Generically a -> Generically a
    forall a. Semigroup a => a -> a -> a
    (<>)

    -- | A type whose instances are defined generically, using the
    -- 'Generic1' representation. 'Generically1' is a higher-kinded
    -- version of 'Generically' that uses 'Generic'.
    --
    -- Generic instances can be derived for type constructors via
    -- @'Generically1' F@ using @-XDerivingVia@.
    --
    -- @
    -- {-# LANGUAGE DeriveGeneric      #-}
    -- {-# LANGUAGE DerivingStrategies #-}
    -- {-# LANGUAGE DerivingVia        #-}
    --
    -- import GHC.Generics (Generic)
    --
    -- data V4 a = V4 a a a a
    --   deriving stock (Functor, Generic1)
    --
    --   deriving Applicative
    --   via Generically1 V4
    -- @
    --
    -- This corresponds to 'Applicative' instances defined by pointwise
    -- lifting:
    --
    -- @
    -- instance Applicative V4 where
    --   pure :: a -> V4 a
    --   pure a = V4 a a a a
    --
    --   liftA2 :: (a -> b -> c) -> (V4 a -> V4 b -> V4 c)
    --   liftA2 (·) (V4 a1 b1 c1 d1) (V4 a2 b2 c2 d2) =
    --     V4 (a1 · a2) (b1 · b2) (c1 · c2) (d1 · d2)
    -- @
    --
    -- Historically this required modifying the type class to include
    -- generic method definitions (@-XDefaultSignatures@) and deriving it
    -- with the @anyclass@ strategy (@-XDeriveAnyClass@). Having a /via
    -- type/ like 'Generically1' decouples the instance from the type
    -- class.
    --
    -- @since 4.17.0.0
    type    Generically1 :: forall k. (k -> Type) -> (k -> Type)
    newtype Generically1 f a where
      Generically1 :: forall {k} f a. f a -> Generically1 @k f a

    -- | @since 4.18.0.0
    instance (Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a) where
       Generically1 f a
    x == :: Generically1 f a -> Generically1 f a -> Bool
    == Generically1 f a
    y = f a -> Rep1 f a
    forall (a :: k). f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a
    x Rep1 f a -> Rep1 f a -> Bool
    forall a. Eq a => a -> a -> Bool
    == f a -> Rep1 f a
    forall (a :: k). f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a
    y
       Generically1 f a
    x /= :: Generically1 f a -> Generically1 f a -> Bool
    /= Generically1 f a
    y = f a -> Rep1 f a
    forall (a :: k). f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a
    x Rep1 f a -> Rep1 f a -> Bool
    forall a. Eq a => a -> a -> Bool
    /= f a -> Rep1 f a
    forall (a :: k). f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a
    y

    -- | @since 4.18.0.0
    instance (Generic1 f, Ord (Rep1 f a)) => Ord (Generically1 f a) where
       Generically1 f a
    x compare :: Generically1 f a -> Generically1 f a -> Ordering
    `compare` Generically1 f a
    y = f a -> Rep1 f a
    forall (a :: k). f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a
    x Rep1 f a -> Rep1 f a -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` f a -> Rep1 f a
    forall (a :: k). f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a
    y

    -- | @since 4.17.0.0
    instance (Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) where
      fmap :: (a -> a') -> (Generically1 f a -> Generically1 f a')
      fmap :: forall a b. (a -> b) -> Generically1 f a -> Generically1 f b
    fmap a -> a'
    f (Generically1 f a
    as) = f a' -> Generically1 f a'
    forall {k} (f :: k -> *) (a :: k). f a -> Generically1 f a
    Generically1
        (Rep1 f a' -> f a'
    forall a. Rep1 f a -> f a
    forall k (f :: k -> *) (a :: k). Generic1 f => Rep1 f a -> f a
    to1 ((a -> a') -> Rep1 f a -> Rep1 f a'
    forall a b. (a -> b) -> Rep1 f a -> Rep1 f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> a'
    f (f a -> Rep1 f a
    forall a. f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a
    as)))

      (<$) :: a -> Generically1 f b -> Generically1 f a
      a
    a <$ :: forall a b. a -> Generically1 f b -> Generically1 f a
    <$ Generically1 f b
    as = f a -> Generically1 f a
    forall {k} (f :: k -> *) (a :: k). f a -> Generically1 f a
    Generically1
        (Rep1 f a -> f a
    forall a. Rep1 f a -> f a
    forall k (f :: k -> *) (a :: k). Generic1 f => Rep1 f a -> f a
    to1 (a
    a a -> Rep1 f b -> Rep1 f a
    forall a b. a -> Rep1 f b -> Rep1 f a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ f b -> Rep1 f b
    forall a. f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f b
    as))

    -- | @since 4.17.0.0
    instance (Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) where
      pure :: a -> Generically1 f a
      pure :: forall a. a -> Generically1 f a
    pure a
    a = f a -> Generically1 f a
    forall {k} (f :: k -> *) (a :: k). f a -> Generically1 f a
    Generically1
        (Rep1 f a -> f a
    forall a. Rep1 f a -> f a
    forall k (f :: k -> *) (a :: k). Generic1 f => Rep1 f a -> f a
    to1 (a -> Rep1 f a
    forall a. a -> Rep1 f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    a))

      (<*>) :: Generically1 f (a1 -> a2) -> Generically1 f a1 -> Generically1 f a2
      Generically1 f (a1 -> a2)
    fs <*> :: forall a b.
    Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b
    <*> Generically1 f a1
    as = f a2 -> Generically1 f a2
    forall {k} (f :: k -> *) (a :: k). f a -> Generically1 f a
    Generically1
        (Rep1 f a2 -> f a2
    forall a. Rep1 f a -> f a
    forall k (f :: k -> *) (a :: k). Generic1 f => Rep1 f a -> f a
    to1 (f (a1 -> a2) -> Rep1 f (a1 -> a2)
    forall a. f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f (a1 -> a2)
    fs Rep1 f (a1 -> a2) -> Rep1 f a1 -> Rep1 f a2
    forall a b. Rep1 f (a -> b) -> Rep1 f a -> Rep1 f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> f a1 -> Rep1 f a1
    forall a. f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a1
    as))

      liftA2 :: (a1 -> a2 -> a3)
             -> (Generically1 f a1 -> Generically1 f a2 -> Generically1 f a3)
      liftA2 :: forall a b c.
    (a -> b -> c)
    -> Generically1 f a -> Generically1 f b -> Generically1 f c
    liftA2 a1 -> a2 -> a3
    (·) (Generically1 f a1
    as) (Generically1 f a2
    bs) = f a3 -> Generically1 f a3
    forall {k} (f :: k -> *) (a :: k). f a -> Generically1 f a
    Generically1
        (Rep1 f a3 -> f a3
    forall a. Rep1 f a -> f a
    forall k (f :: k -> *) (a :: k). Generic1 f => Rep1 f a -> f a
    to1 ((a1 -> a2 -> a3) -> Rep1 f a1 -> Rep1 f a2 -> Rep1 f a3
    forall a b c. (a -> b -> c) -> Rep1 f a -> Rep1 f b -> Rep1 f c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 a1 -> a2 -> a3
    (·) (f a1 -> Rep1 f a1
    forall a. f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a1
    as) (f a2 -> Rep1 f a2
    forall a. f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a2
    bs)))

    -- | @since 4.17.0.0
    instance (Generic1 f, Alternative (Rep1 f)) => Alternative (Generically1 f) where
      empty :: Generically1 f a
      empty :: forall a. Generically1 f a
    empty = f a -> Generically1 f a
    forall {k} (f :: k -> *) (a :: k). f a -> Generically1 f a
    Generically1
        (Rep1 f a -> f a
    forall a. Rep1 f a -> f a
    forall k (f :: k -> *) (a :: k). Generic1 f => Rep1 f a -> f a
    to1 Rep1 f a
    forall a. Rep1 f a
    forall (f :: * -> *) a. Alternative f => f a
    empty)

      (<|>) :: Generically1 f a -> Generically1 f a -> Generically1 f a
      Generically1 f a
    as1 <|> :: forall a. Generically1 f a -> Generically1 f a -> Generically1 f a
    <|> Generically1 f a
    as2 = f a -> Generically1 f a
    forall {k} (f :: k -> *) (a :: k). f a -> Generically1 f a
    Generically1
        (Rep1 f a -> f a
    forall a. Rep1 f a -> f a
    forall k (f :: k -> *) (a :: k). Generic1 f => Rep1 f a -> f a
    to1 (f a -> Rep1 f a
    forall a. f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a
    as1 Rep1 f a -> Rep1 f a -> Rep1 f a
    forall a. Rep1 f a -> Rep1 f a -> Rep1 f a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> f a -> Rep1 f a
    forall a. f a -> Rep1 f a
    forall k (f :: k -> *) (a :: k). Generic1 f => f a -> Rep1 f a
    from1 f a
    as2))

    --------------------------------------------------------------------------------
    -- Meta-data
    --------------------------------------------------------------------------------

    -- | 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 4.9.0.0
    data Meta = MetaData Symbol Symbol Symbol Bool
              | MetaCons Symbol FixityI Bool
              | MetaSel  (Maybe Symbol)
                         SourceUnpackedness SourceStrictness DecidedStrictness

    --------------------------------------------------------------------------------
    -- Derived instances
    --------------------------------------------------------------------------------

    -- | @since 4.8.0.0
    deriving instance Generic Void

    -- | @since 4.6.0.0
    deriving instance Generic [a]

    -- | @since 4.6.0.0
    deriving instance Generic (NonEmpty a)

    -- | @since 4.6.0.0
    deriving instance Generic (Maybe a)

    -- | @since 4.6.0.0
    deriving instance Generic (Either a b)

    -- | @since 4.6.0.0
    deriving instance Generic Bool

    -- | @since 4.6.0.0
    deriving instance Generic Ordering

    -- | @since 4.6.0.0
    deriving instance Generic (Proxy t)

    -- | @since 4.6.0.0
    deriving instance Generic ()

    -- | @since 4.15
    deriving instance Generic (Solo a)

    -- | @since 4.6.0.0
    deriving instance Generic ((,) a b)

    -- | @since 4.6.0.0
    deriving instance Generic ((,,) a b c)

    -- | @since 4.6.0.0
    deriving instance Generic ((,,,) a b c d)

    -- | @since 4.6.0.0
    deriving instance Generic ((,,,,) a b c d e)

    -- | @since 4.6.0.0
    deriving instance Generic ((,,,,,) a b c d e f)

    -- | @since 4.6.0.0
    deriving instance Generic ((,,,,,,) a b c d e f g)

    -- | @since 4.16.0.0
    deriving instance Generic ((,,,,,,,) a b c d e f g h)

    -- | @since 4.16.0.0
    deriving instance Generic ((,,,,,,,,) a b c d e f g h i)

    -- | @since 4.16.0.0
    deriving instance Generic ((,,,,,,,,,) a b c d e f g h i j)

    -- | @since 4.16.0.0
    deriving instance Generic ((,,,,,,,,,,) a b c d e f g h i j k)

    -- | @since 4.16.0.0
    deriving instance Generic ((,,,,,,,,,,,) a b c d e f g h i j k l)

    -- | @since 4.16.0.0
    deriving instance Generic ((,,,,,,,,,,,,) a b c d e f g h i j k l m)

    -- | @since 4.16.0.0
    deriving instance Generic ((,,,,,,,,,,,,,) a b c d e f g h i j k l m n)

    -- | @since 4.16.0.0
    deriving instance Generic ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o)

    -- | @since 4.12.0.0
    deriving instance Generic (Down a)

    -- | @since 4.15.0.0
    deriving instance Generic SrcLoc

    -- | @since 4.15.0.0
    deriving instance Generic GeneralCategory

    -- | @since 4.15.0.0
    deriving instance Generic Fingerprint

    -- | @since 4.6.0.0
    deriving instance Generic1 []

    -- | @since 4.6.0.0
    deriving instance Generic1 NonEmpty

    -- | @since 4.6.0.0
    deriving instance Generic1 Maybe

    -- | @since 4.6.0.0
    deriving instance Generic1 (Either a)

    -- | @since 4.6.0.0
    deriving instance Generic1 Proxy

    -- | @since 4.15
    deriving instance Generic1 Solo

    -- | @since 4.6.0.0
    deriving instance Generic1 ((,) a)

    -- | @since 4.6.0.0
    deriving instance Generic1 ((,,) a b)

    -- | @since 4.6.0.0
    deriving instance Generic1 ((,,,) a b c)

    -- | @since 4.6.0.0
    deriving instance Generic1 ((,,,,) a b c d)

    -- | @since 4.6.0.0
    deriving instance Generic1 ((,,,,,) a b c d e)

    -- | @since 4.6.0.0
    deriving instance Generic1 ((,,,,,,) a b c d e f)

    -- | @since 4.16.0.0
    deriving instance Generic1 ((,,,,,,,) a b c d e f g)

    -- | @since 4.16.0.0
    deriving instance Generic1 ((,,,,,,,,) a b c d e f g h)

    -- | @since 4.16.0.0
    deriving instance Generic1 ((,,,,,,,,,) a b c d e f g h i)

    -- | @since 4.16.0.0
    deriving instance Generic1 ((,,,,,,,,,,) a b c d e f g h i j)

    -- | @since 4.16.0.0
    deriving instance Generic1 ((,,,,,,,,,,,) a b c d e f g h i j k)

    -- | @since 4.16.0.0
    deriving instance Generic1 ((,,,,,,,,,,,,) a b c d e f g h i j k l)

    -- | @since 4.16.0.0
    deriving instance Generic1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m)

    -- | @since 4.16.0.0
    deriving instance Generic1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n)

    -- | @since 4.12.0.0
    deriving instance Generic1 Down

    --------------------------------------------------------------------------------
    -- Copied from the singletons package
    --------------------------------------------------------------------------------

    -- | The singleton kind-indexed data family.
    data family Sing (a :: k)

    -- | A 'SingI' constraint is essentially an implicitly-passed singleton.
    class SingI (a :: k) where
      -- | Produce the singleton explicitly. You will likely need the @ScopedTypeVariables@
      -- extension to use this method the way you want.
      sing :: Sing a

    -- | The 'SingKind' class is essentially a /kind/ class. It classifies all kinds
    -- for which singletons are defined. The class supports converting between a singleton
    -- type and the base (unrefined) type which it is built from.
    class SingKind k where
      -- | Get a base type from a proxy for the promoted kind. For example,
      -- @DemoteRep Bool@ will be the type @Bool@.
      type DemoteRep k :: Type

      -- | Convert a singleton to its unrefined version.
      fromSing :: Sing (a :: k) -> DemoteRep k

    -- Singleton symbols
    data instance Sing (s :: Symbol) where
      SSym :: KnownSymbol s => Sing s

    -- | @since 4.9.0.0
    instance KnownSymbol a => SingI a where sing :: Sing a
    sing = Sing a
    forall (a :: Symbol). KnownSymbol a => Sing a
    SSym

    -- | @since 4.9.0.0
    instance SingKind Symbol where
      type DemoteRep Symbol = String
      fromSing :: forall (a :: Symbol). Sing a -> DemoteRep Symbol
    fromSing (Sing a
    R:SingSymbols a
    SSym :: Sing s) = Proxy a -> String
    forall (n :: Symbol) (proxy :: Symbol -> *).
    KnownSymbol n =>
    proxy n -> String
    symbolVal (Proxy a
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy s)

    -- Singleton booleans
    data instance Sing (a :: Bool) where
      STrue  :: Sing 'True
      SFalse :: Sing 'False

    -- | @since 4.9.0.0
    instance SingI 'True  where sing :: Sing 'True
    sing = Sing 'True
    STrue

    -- | @since 4.9.0.0
    instance SingI 'False where sing :: Sing 'False
    sing = Sing 'False
    SFalse

    -- | @since 4.9.0.0
    instance SingKind Bool where
      type DemoteRep Bool = Bool
      fromSing :: forall (a :: Bool). Sing a -> DemoteRep Bool
    fromSing Sing a
    R:SingBoola a
    STrue  = Bool
    DemoteRep Bool
    True
      fromSing Sing a
    R:SingBoola a
    SFalse = Bool
    DemoteRep Bool
    False

    -- Singleton Maybe
    data instance Sing (b :: Maybe a) where
      SNothing :: Sing 'Nothing
      SJust    :: Sing a -> Sing ('Just a)

    -- | @since 4.9.0.0
    instance            SingI 'Nothing  where sing :: Sing 'Nothing
    sing = Sing 'Nothing
    forall a. Sing 'Nothing
    SNothing

    -- | @since 4.9.0.0
    instance SingI a => SingI ('Just a) where sing :: Sing ('Just a)
    sing = Sing a -> Sing ('Just a)
    forall {k} (a :: k). Sing a -> Sing ('Just a)
    SJust Sing a
    forall k (a :: k). SingI a => Sing a
    sing

    -- | @since 4.9.0.0
    instance SingKind a => SingKind (Maybe a) where
      type DemoteRep (Maybe a) = Maybe (DemoteRep a)
      fromSing :: forall (a :: Maybe a). Sing a -> DemoteRep (Maybe a)
    fromSing Sing a
    R:SingMaybeb a a
    SNothing  = Maybe (DemoteRep a)
    DemoteRep (Maybe a)
    forall a. Maybe a
    Nothing
      fromSing (SJust Sing a
    a) = DemoteRep a -> Maybe (DemoteRep a)
    forall a. a -> Maybe a
    Just (Sing a -> DemoteRep a
    forall (a :: a). Sing a -> DemoteRep a
    forall k (a :: k). SingKind k => Sing a -> DemoteRep k
    fromSing Sing a
    a)

    -- Singleton Fixity
    data instance Sing (a :: FixityI) where
      SPrefix :: Sing 'PrefixI
      SInfix  :: Sing a -> Integer -> Sing ('InfixI a n)

    -- | @since 4.9.0.0
    instance SingI 'PrefixI where sing :: Sing 'PrefixI
    sing = Sing 'PrefixI
    SPrefix

    -- | @since 4.9.0.0
    instance (SingI a, KnownNat n) => SingI ('InfixI a n) where
      sing :: Sing ('InfixI a n)
    sing = Sing a -> Integer -> Sing ('InfixI a n)
    forall (a :: Associativity) (n :: Nat).
    Sing a -> Integer -> Sing ('InfixI a n)
    SInfix (Sing a
    forall k (a :: k). SingI a => Sing a
    sing :: Sing a) (Proxy n -> Integer
    forall (n :: Nat) (proxy :: Nat -> *).
    KnownNat n =>
    proxy n -> Integer
    natVal (Proxy n
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy n))

    -- | @since 4.9.0.0
    instance SingKind FixityI where
      type DemoteRep FixityI = Fixity
      fromSing :: forall (a :: FixityI). Sing a -> DemoteRep FixityI
    fromSing Sing a
    R:SingFixityIa a
    SPrefix      = DemoteRep FixityI
    Fixity
    Prefix
      fromSing (SInfix Sing a
    a Integer
    n) = Associativity -> Int -> Fixity
    Infix (Sing a -> DemoteRep Associativity
    forall k (a :: k). SingKind k => Sing a -> DemoteRep k
    forall (a :: Associativity). Sing a -> DemoteRep Associativity
    fromSing Sing a
    a) (Integer -> Int
    integerToInt Integer
    n)

    -- Singleton Associativity
    data instance Sing (a :: Associativity) where
      SLeftAssociative  :: Sing 'LeftAssociative
      SRightAssociative :: Sing 'RightAssociative
      SNotAssociative   :: Sing 'NotAssociative

    -- | @since 4.9.0.0
    instance SingI 'LeftAssociative  where sing :: Sing 'LeftAssociative
    sing = Sing 'LeftAssociative
    SLeftAssociative

    -- | @since 4.9.0.0
    instance SingI 'RightAssociative where sing :: Sing 'RightAssociative
    sing = Sing 'RightAssociative
    SRightAssociative

    -- | @since 4.9.0.0
    instance SingI 'NotAssociative   where sing :: Sing 'NotAssociative
    sing = Sing 'NotAssociative
    SNotAssociative

    -- | @since 4.0.0.0
    instance SingKind Associativity where
      type DemoteRep Associativity = Associativity
      fromSing :: forall (a :: Associativity). Sing a -> DemoteRep Associativity
    fromSing Sing a
    R:SingAssociativitya a
    SLeftAssociative  = DemoteRep Associativity
    Associativity
    LeftAssociative
      fromSing Sing a
    R:SingAssociativitya a
    SRightAssociative = DemoteRep Associativity
    Associativity
    RightAssociative
      fromSing Sing a
    R:SingAssociativitya a
    SNotAssociative   = DemoteRep Associativity
    Associativity
    NotAssociative

    -- Singleton SourceUnpackedness
    data instance Sing (a :: SourceUnpackedness) where
      SNoSourceUnpackedness :: Sing 'NoSourceUnpackedness
      SSourceNoUnpack       :: Sing 'SourceNoUnpack
      SSourceUnpack         :: Sing 'SourceUnpack

    -- | @since 4.9.0.0
    instance SingI 'NoSourceUnpackedness where sing :: Sing 'NoSourceUnpackedness
    sing = Sing 'NoSourceUnpackedness
    SNoSourceUnpackedness

    -- | @since 4.9.0.0
    instance SingI 'SourceNoUnpack       where sing :: Sing 'SourceNoUnpack
    sing = Sing 'SourceNoUnpack
    SSourceNoUnpack

    -- | @since 4.9.0.0
    instance SingI 'SourceUnpack         where sing :: Sing 'SourceUnpack
    sing = Sing 'SourceUnpack
    SSourceUnpack

    -- | @since 4.9.0.0
    instance SingKind SourceUnpackedness where
      type DemoteRep SourceUnpackedness = SourceUnpackedness
      fromSing :: forall (a :: SourceUnpackedness).
    Sing a -> DemoteRep SourceUnpackedness
    fromSing Sing a
    R:SingSourceUnpackednessa a
    SNoSourceUnpackedness = DemoteRep SourceUnpackedness
    SourceUnpackedness
    NoSourceUnpackedness
      fromSing Sing a
    R:SingSourceUnpackednessa a
    SSourceNoUnpack       = DemoteRep SourceUnpackedness
    SourceUnpackedness
    SourceNoUnpack
      fromSing Sing a
    R:SingSourceUnpackednessa a
    SSourceUnpack         = DemoteRep SourceUnpackedness
    SourceUnpackedness
    SourceUnpack

    -- Singleton SourceStrictness
    data instance Sing (a :: SourceStrictness) where
      SNoSourceStrictness :: Sing 'NoSourceStrictness
      SSourceLazy         :: Sing 'SourceLazy
      SSourceStrict       :: Sing 'SourceStrict

    -- | @since 4.9.0.0
    instance SingI 'NoSourceStrictness where sing :: Sing 'NoSourceStrictness
    sing = Sing 'NoSourceStrictness
    SNoSourceStrictness

    -- | @since 4.9.0.0
    instance SingI 'SourceLazy         where sing :: Sing 'SourceLazy
    sing = Sing 'SourceLazy
    SSourceLazy

    -- | @since 4.9.0.0
    instance SingI 'SourceStrict       where sing :: Sing 'SourceStrict
    sing = Sing 'SourceStrict
    SSourceStrict

    -- | @since 4.9.0.0
    instance SingKind SourceStrictness where
      type DemoteRep SourceStrictness = SourceStrictness
      fromSing :: forall (a :: SourceStrictness).
    Sing a -> DemoteRep SourceStrictness
    fromSing Sing a
    R:SingSourceStrictnessa a
    SNoSourceStrictness = DemoteRep SourceStrictness
    SourceStrictness
    NoSourceStrictness
      fromSing Sing a
    R:SingSourceStrictnessa a
    SSourceLazy         = DemoteRep SourceStrictness
    SourceStrictness
    SourceLazy
      fromSing Sing a
    R:SingSourceStrictnessa a
    SSourceStrict       = DemoteRep SourceStrictness
    SourceStrictness
    SourceStrict

    -- Singleton DecidedStrictness
    data instance Sing (a :: DecidedStrictness) where
      SDecidedLazy   :: Sing 'DecidedLazy
      SDecidedStrict :: Sing 'DecidedStrict
      SDecidedUnpack :: Sing 'DecidedUnpack

    -- | @since 4.9.0.0
    instance SingI 'DecidedLazy   where sing :: Sing 'DecidedLazy
    sing = Sing 'DecidedLazy
    SDecidedLazy

    -- | @since 4.9.0.0
    instance SingI 'DecidedStrict where sing :: Sing 'DecidedStrict
    sing = Sing 'DecidedStrict
    SDecidedStrict

    -- | @since 4.9.0.0
    instance SingI 'DecidedUnpack where sing :: Sing 'DecidedUnpack
    sing = Sing 'DecidedUnpack
    SDecidedUnpack

    -- | @since 4.9.0.0
    instance SingKind DecidedStrictness where
      type DemoteRep DecidedStrictness = DecidedStrictness
      fromSing :: forall (a :: DecidedStrictness).
    Sing a -> DemoteRep DecidedStrictness
    fromSing Sing a
    R:SingDecidedStrictnessa a
    SDecidedLazy   = DemoteRep DecidedStrictness
    DecidedStrictness
    DecidedLazy
      fromSing Sing a
    R:SingDecidedStrictnessa a
    SDecidedStrict = DemoteRep DecidedStrictness
    DecidedStrictness
    DecidedStrict
      fromSing Sing a
    R:SingDecidedStrictnessa a
    SDecidedUnpack = DemoteRep DecidedStrictness
    DecidedStrictness
    DecidedUnpack