-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Generic programming library with representation types
--   
--   Generic programming library providing structural polymorphism and
--   other features.
@package RepLib
@version 0.5.4.1


-- | Basic data structure and class for representation types
module Generics.RepLib.R

-- | A value of type <tt>R a</tt> is a representation of a type <tt>a</tt>.
data R a
[Int] :: R Int
[Char] :: R Char
[Integer] :: R Integer
[Float] :: R Float
[Double] :: R Double
[Rational] :: R Rational
[IOError] :: R IOError
[IO] :: (Rep a) => R a -> R (IO a)
[Arrow] :: (Rep a, Rep b) => R a -> R b -> R (a -> b)
[Data] :: DT -> [Con R a] -> R a
[Abstract] :: DT -> R a
[Equal] :: (Rep a, Rep b) => R a -> R b -> R (a :~: b)

-- | Representation of a data constructor includes an embedding between the
--   datatype and a list of other types as well as the representation of
--   that list of other types.
data Con r a
[Con] :: Emb l a -> MTup r l -> Con r a

-- | An embedding between a list of types <tt>l</tt> and a datatype
--   <tt>a</tt>, based on a particular data constructor. The to function is
--   a wrapper for the constructor, the from function pattern matches on
--   the constructor.
data Emb l a
Emb :: l -> a -> a -> Maybe l -> Maybe [String] -> String -> Fixity -> Emb l a
[to] :: Emb l a -> l -> a
[from] :: Emb l a -> a -> Maybe l
[labels] :: Emb l a -> Maybe [String]
[name] :: Emb l a -> String
[fixity] :: Emb l a -> Fixity
data Fixity
Nonfix :: Fixity
Infix :: Int -> Fixity
[prec] :: Fixity -> Int
Infixl :: Int -> Fixity
[prec] :: Fixity -> Int
Infixr :: Int -> Fixity
[prec] :: Fixity -> Int

-- | Information about a datatype, including its fully qualified name and
--   representation of its type arguments.
data DT
DT :: String -> (MTup R l) -> DT

-- | An empty list of types
data Nil
Nil :: Nil

-- | Cons for a list of types
data a (:*:) l
(:*:) :: a -> l -> (:*:) a l

-- | A heterogeneous list
data MTup r l
[MNil] :: MTup r Nil
[:+:] :: (Rep a) => r a -> MTup r l -> MTup r (a :*: l)

-- | A class of representable types
class Rep a
rep :: Rep a => R a

-- | Use a concrete <tt><a>R</a> a</tt> for a <tt><a>Rep</a> a</tt>
--   dictionary
withRep :: R a -> (Rep a => r) -> r
rUnitEmb :: Emb Nil ()
rUnit :: R ()
rTup2 :: forall a b. (Rep a, Rep b) => R (a, b)
rPairEmb :: Emb (a :*: b :*: Nil) (a, b)
rList :: forall a. Rep a => R [a]
rNilEmb :: Emb Nil [a]
rConsEmb :: Emb (a :*: [a] :*: Nil) [a]
instance GHC.Show.Show (Generics.RepLib.R.R a)
instance GHC.Show.Show Generics.RepLib.R.DT
instance GHC.Show.Show (Generics.RepLib.R.MTup Generics.RepLib.R.R l)
instance GHC.Classes.Eq (Generics.RepLib.R.R a)
instance GHC.Classes.Ord (Generics.RepLib.R.R a)
instance Generics.RepLib.R.Rep GHC.Types.Int
instance Generics.RepLib.R.Rep GHC.Types.Char
instance Generics.RepLib.R.Rep GHC.Integer.Type.Integer
instance Generics.RepLib.R.Rep GHC.Types.Float
instance Generics.RepLib.R.Rep GHC.Types.Double
instance Generics.RepLib.R.Rep GHC.Real.Rational
instance Generics.RepLib.R.Rep GHC.IO.Exception.IOError
instance Generics.RepLib.R.Rep a => Generics.RepLib.R.Rep (GHC.Types.IO a)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b) => Generics.RepLib.R.Rep (a -> b)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b) => Generics.RepLib.R.Rep (a Data.Type.Equality.:~: b)
instance Generics.RepLib.R.Rep ()
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b) => Generics.RepLib.R.Rep (a, b)
instance Generics.RepLib.R.Rep a => Generics.RepLib.R.Rep [a]


module Generics.RepLib.R1
data R1 ctx a
[Int1] :: R1 ctx Int
[Char1] :: R1 ctx Char
[Integer1] :: R1 ctx Integer
[Float1] :: R1 ctx Float
[Double1] :: R1 ctx Double
[Rational1] :: R1 ctx Rational
[IOError1] :: R1 ctx IOError
[IO1] :: (Rep a) => ctx a -> R1 ctx (IO a)
[Arrow1] :: (Rep a, Rep b) => ctx a -> ctx b -> R1 ctx (a -> b)
[Data1] :: DT -> [Con ctx a] -> R1 ctx a
[Abstract1] :: DT -> R1 ctx a
[Equal1] :: (Rep a, Rep b) => ctx a -> ctx b -> R1 ctx (a :~: b)
class Sat a
dict :: Sat a => a
class Rep a => Rep1 ctx a
rep1 :: Rep1 ctx a => R1 ctx a

-- | Access a representation, given a proxy
getRepC :: Rep b => c b -> R b

-- | Transform a parameterized rep to a vanilla rep
toR :: R1 c a -> R a
rTup2_1 :: forall a b ctx. (Rep a, Rep b) => ctx a -> ctx b -> R1 ctx (a, b)
rList1 :: forall a ctx. Rep a => ctx a -> ctx [a] -> R1 ctx [a]
instance Generics.RepLib.R1.Rep1 ctx GHC.Types.Int
instance Generics.RepLib.R1.Rep1 ctx GHC.Types.Char
instance Generics.RepLib.R1.Rep1 ctx GHC.Integer.Type.Integer
instance Generics.RepLib.R1.Rep1 ctx GHC.Types.Float
instance Generics.RepLib.R1.Rep1 ctx GHC.Types.Double
instance Generics.RepLib.R1.Rep1 ctx GHC.IO.Exception.IOError
instance Generics.RepLib.R1.Rep1 ctx GHC.Real.Rational
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R1.Sat (ctx a)) => Generics.RepLib.R1.Rep1 ctx (GHC.Types.IO a)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R1.Sat (ctx b)) => Generics.RepLib.R1.Rep1 ctx (a -> b)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R1.Sat (ctx b)) => Generics.RepLib.R1.Rep1 ctx (a Data.Type.Equality.:~: b)
instance Generics.RepLib.R1.Rep1 ctx ()
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R.Rep b, Generics.RepLib.R1.Sat (ctx b)) => Generics.RepLib.R1.Rep1 ctx (a, b)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R1.Sat (ctx [a])) => Generics.RepLib.R1.Rep1 ctx [a]
instance GHC.Show.Show (Generics.RepLib.R1.R1 c a)


-- | Automatically derive representations and instance declarations for
--   user defined datatypes. The typical use is <tt> $(derive [''MyType1,
--   ''MyType2]) </tt>
module Generics.RepLib.Derive

-- | Generate representations (both basic and parameterized) for a list of
--   types.
derive :: [Name] -> Q [Dec]

-- | Generate abstract representations for a list of types.
derive_abstract :: [Name] -> Q [Dec]
instance GHC.Base.Applicative Generics.RepLib.Derive.QN
instance Control.Monad.IO.Class.MonadIO Generics.RepLib.Derive.QN
instance Control.Monad.Fail.MonadFail Generics.RepLib.Derive.QN
instance Control.Monad.Writer.Class.MonadWriter (Data.Set.Internal.Set GHC.Types.Int) Generics.RepLib.Derive.QN
instance GHC.Base.Functor Generics.RepLib.Derive.QN
instance GHC.Base.Monad Generics.RepLib.Derive.QN
instance Language.Haskell.TH.Syntax.Quasi Generics.RepLib.Derive.QN


-- | Representations for Prelude types, necessary to (automatically) derive
--   representations of user defined types.
module Generics.RepLib.PreludeReps
rTup7_1 :: forall ctx_aonI a_11 b_12 c_13 d_14 e_15 f_16 g_17. (Rep a_11, Rep b_12, Rep c_13, Rep d_14, Rep e_15, Rep f_16, Rep g_17) => (ctx_aonI a_11, ctx_aonI b_12, ctx_aonI c_13, ctx_aonI d_14, ctx_aonI e_15, ctx_aonI f_16, ctx_aonI g_17) -> R1 ctx_aonI ((,,,,,,) a_11 b_12 c_13 d_14 e_15 f_16 g_17)
rTup7 :: forall a_11 b_12 c_13 d_14 e_15 f_16 g_17. (Rep a_11, Rep b_12, Rep c_13, Rep d_14, Rep e_15, Rep f_16, Rep g_17) => R ((,,,,,,) a_11 b_12 c_13 d_14 e_15 f_16 g_17)
rTup6_1 :: forall ctx_aomX a_11 b_12 c_13 d_14 e_15 f_16. (Rep a_11, Rep b_12, Rep c_13, Rep d_14, Rep e_15, Rep f_16) => (ctx_aomX a_11, ctx_aomX b_12, ctx_aomX c_13, ctx_aomX d_14, ctx_aomX e_15, ctx_aomX f_16) -> R1 ctx_aomX ((,,,,,) a_11 b_12 c_13 d_14 e_15 f_16)
rTup6 :: forall a_11 b_12 c_13 d_14 e_15 f_16. (Rep a_11, Rep b_12, Rep c_13, Rep d_14, Rep e_15, Rep f_16) => R ((,,,,,) a_11 b_12 c_13 d_14 e_15 f_16)
rTup5_1 :: forall ctx_aomj a_11 b_12 c_13 d_14 e_15. (Rep a_11, Rep b_12, Rep c_13, Rep d_14, Rep e_15) => (ctx_aomj a_11, ctx_aomj b_12, ctx_aomj c_13, ctx_aomj d_14, ctx_aomj e_15) -> R1 ctx_aomj ((,,,,) a_11 b_12 c_13 d_14 e_15)
rTup5 :: forall a_11 b_12 c_13 d_14 e_15. (Rep a_11, Rep b_12, Rep c_13, Rep d_14, Rep e_15) => R ((,,,,) a_11 b_12 c_13 d_14 e_15)
rTup4_1 :: forall ctx_aolM a_11 b_12 c_13 d_14. (Rep a_11, Rep b_12, Rep c_13, Rep d_14) => (ctx_aolM a_11, ctx_aolM b_12, ctx_aolM c_13, ctx_aolM d_14) -> R1 ctx_aolM ((,,,) a_11 b_12 c_13 d_14)
rTup4 :: forall a_11 b_12 c_13 d_14. (Rep a_11, Rep b_12, Rep c_13, Rep d_14) => R ((,,,) a_11 b_12 c_13 d_14)
rTup3_1 :: forall ctx_aolm a_11 b_12 c_13. (Rep a_11, Rep b_12, Rep c_13) => (ctx_aolm a_11, ctx_aolm b_12, ctx_aolm c_13) -> R1 ctx_aolm ((,,) a_11 b_12 c_13)
rTup3 :: forall a_11 b_12 c_13. (Rep a_11, Rep b_12, Rep c_13) => R ((,,) a_11 b_12 c_13)
rOrdering1 :: forall ctx_aol9. () -> () -> () -> R1 ctx_aol9 Ordering
rOrdering :: R Ordering
rEither1 :: forall ctx_aokO a_aokA b_aokB. (Rep a_aokA, Rep b_aokB) => ctx_aokO a_aokA -> ctx_aokO b_aokB -> R1 ctx_aokO (Either a_aokA b_aokB)
rEither :: forall a_aokA b_aokB. (Rep a_aokA, Rep b_aokB) => R (Either a_aokA b_aokB)
rMaybe1 :: forall ctx_aokm a_11. Rep a_11 => () -> ctx_aokm a_11 -> R1 ctx_aokm (Maybe a_11)
rMaybe :: forall a_11. Rep a_11 => R (Maybe a_11)
rBool1 :: forall ctx_aokd. () -> () -> R1 ctx_aokd Bool
rBool :: R Bool
instance Generics.RepLib.R.Rep GHC.Types.Bool
instance Generics.RepLib.R1.Rep1 ctx GHC.Types.Bool
instance Generics.RepLib.R.Rep a => Generics.RepLib.R.Rep (GHC.Base.Maybe a)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R1.Sat (ctx a)) => Generics.RepLib.R1.Rep1 ctx (GHC.Base.Maybe a)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b) => Generics.RepLib.R.Rep (Data.Either.Either a b)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R1.Sat (ctx b)) => Generics.RepLib.R1.Rep1 ctx (Data.Either.Either a b)
instance Generics.RepLib.R.Rep GHC.Types.Ordering
instance Generics.RepLib.R1.Rep1 ctx GHC.Types.Ordering
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c) => Generics.RepLib.R.Rep (a, b, c)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R1.Sat (ctx b), Generics.RepLib.R1.Sat (ctx c)) => Generics.RepLib.R1.Rep1 ctx (a, b, c)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c, Generics.RepLib.R.Rep d) => Generics.RepLib.R.Rep (a, b, c, d)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c, Generics.RepLib.R.Rep d, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R1.Sat (ctx b), Generics.RepLib.R1.Sat (ctx c), Generics.RepLib.R1.Sat (ctx d)) => Generics.RepLib.R1.Rep1 ctx (a, b, c, d)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c, Generics.RepLib.R.Rep d, Generics.RepLib.R.Rep e) => Generics.RepLib.R.Rep (a, b, c, d, e)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c, Generics.RepLib.R.Rep d, Generics.RepLib.R.Rep e, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R1.Sat (ctx b), Generics.RepLib.R1.Sat (ctx c), Generics.RepLib.R1.Sat (ctx d), Generics.RepLib.R1.Sat (ctx e)) => Generics.RepLib.R1.Rep1 ctx (a, b, c, d, e)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c, Generics.RepLib.R.Rep d, Generics.RepLib.R.Rep e, Generics.RepLib.R.Rep f) => Generics.RepLib.R.Rep (a, b, c, d, e, f)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c, Generics.RepLib.R.Rep d, Generics.RepLib.R.Rep e, Generics.RepLib.R.Rep f, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R1.Sat (ctx b), Generics.RepLib.R1.Sat (ctx c), Generics.RepLib.R1.Sat (ctx d), Generics.RepLib.R1.Sat (ctx e), Generics.RepLib.R1.Sat (ctx f)) => Generics.RepLib.R1.Rep1 ctx (a, b, c, d, e, f)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c, Generics.RepLib.R.Rep d, Generics.RepLib.R.Rep e, Generics.RepLib.R.Rep f, Generics.RepLib.R.Rep g) => Generics.RepLib.R.Rep (a, b, c, d, e, f, g)
instance (Generics.RepLib.R.Rep a, Generics.RepLib.R.Rep b, Generics.RepLib.R.Rep c, Generics.RepLib.R.Rep d, Generics.RepLib.R.Rep e, Generics.RepLib.R.Rep f, Generics.RepLib.R.Rep g, Generics.RepLib.R1.Sat (ctx a), Generics.RepLib.R1.Sat (ctx b), Generics.RepLib.R1.Sat (ctx c), Generics.RepLib.R1.Sat (ctx d), Generics.RepLib.R1.Sat (ctx e), Generics.RepLib.R1.Sat (ctx f), Generics.RepLib.R1.Sat (ctx g)) => Generics.RepLib.R1.Rep1 ctx (a, b, c, d, e, f, g)


-- | Abstract Reps for Common Abstract Datatypes
module Generics.RepLib.AbstractReps
rSet1 :: forall ctx_as8m a_acXy. Rep a_acXy => R1 ctx_as8m (Set a_acXy)
rSet :: forall a_acXy. Rep a_acXy => R (Set a_acXy)
rMap1 :: forall ctx_as81 k_as7N a_as7O. (Rep k_as7N, Rep a_as7O) => R1 ctx_as81 (Map k_as7N a_as7O)
rMap :: forall k_as7N a_as7O. (Rep k_as7N, Rep a_as7O) => R (Map k_as7N a_as7O)
instance (Generics.RepLib.R.Rep k, Generics.RepLib.R.Rep a) => Generics.RepLib.R.Rep (Data.Map.Internal.Map k a)
instance (Generics.RepLib.R.Rep k, Generics.RepLib.R.Rep a) => Generics.RepLib.R1.Rep1 ctx (Data.Map.Internal.Map k a)
instance Generics.RepLib.R.Rep a => Generics.RepLib.R.Rep (Data.Set.Internal.Set a)
instance Generics.RepLib.R.Rep a => Generics.RepLib.R1.Rep1 ctx (Data.Set.Internal.Set a)


-- | Auxiliary operations to aid in the definition of type-indexed
--   functions
module Generics.RepLib.RepAux

-- | Determine if two reps are for the same type
eqR :: R a -> R b -> Bool

-- | The type-safe cast operation, implicit arguments
cast :: forall a b. (Rep a, Rep b) => a -> Maybe b

-- | The type-safe cast operation, explicit arguments
castR :: R a -> R b -> a -> Maybe b

-- | Leibniz equality between types, implicit representations
gcast :: forall a b c. (Rep a, Rep b) => c a -> Maybe (c b)

-- | Leibniz equality between types, explicit representations
gcastR :: forall a b c. R a -> R b -> c a -> Maybe (c b)

-- | Heterogeneous Ordering
compareR :: R a -> R b -> Ordering

-- | Given a list of constructor representations for a datatype, determine
--   which constructor formed the datatype.
findCon :: [Con ctx a] -> a -> Val ctx a

-- | A datastructure to store the results of findCon
data Val ctx a
[Val] :: Emb l a -> MTup ctx l -> l -> Val ctx a

-- | A fold left for heterogeneous lists
foldl_l :: (forall a. Rep a => ctx a -> b -> a -> b) -> b -> (MTup ctx l) -> l -> b

-- | A fold right operation for heterogeneous lists, that folds a function
--   expecting a type type representation across each element of the list.
foldr_l :: (forall a. Rep a => ctx a -> a -> b -> b) -> b -> (MTup ctx l) -> l -> b

-- | A map for heterogeneous lists
map_l :: (forall a. Rep a => ctx a -> a -> a) -> (MTup ctx l) -> l -> l

-- | Transform a heterogeneous list in to a standard list
mapQ_l :: (forall a. Rep a => ctx a -> a -> r) -> MTup ctx l -> l -> [r]

-- | mapM for heterogeneous lists
mapM_l :: (Monad m) => (forall a. Rep a => ctx a -> a -> m a) -> MTup ctx l -> l -> m l

-- | Generate a heterogeneous list from metadata
fromTup :: (forall a. Rep a => ctx a -> a) -> MTup ctx l -> l

-- | Generate a heterogeneous list from metadata, in a monad
fromTupM :: (Monad m) => (forall a. Rep a => ctx a -> m a) -> MTup ctx l -> m l

-- | Generate a normal lists from metadata
toList :: (forall a. Rep a => ctx a -> b) -> MTup ctx l -> [b]

-- | A SYB style traversal
type Traversal = forall a. Rep a => a -> a

-- | SYB style query type
type Query r = forall a. Rep a => a -> r

-- | SYB style monadic map type
type MapM m = forall a. Rep a => a -> m a

-- | Map a traversal across the kids of a data structure
gmapT :: forall a. Rep a => Traversal -> a -> a
gmapQ :: forall a r. Rep a => Query r -> a -> [r]
gmapM :: forall a m. (Rep a, Monad m) => MapM m -> a -> m a
type Traversal1 ctx = forall a. Rep a => ctx a -> a -> a
type Query1 ctx r = forall a. Rep a => ctx a -> a -> r
type MapM1 ctx m = forall a. Rep a => ctx a -> a -> m a
gmapT1 :: forall a ctx. (Rep1 ctx a) => Traversal1 ctx -> a -> a
gmapQ1 :: forall a ctx r. (Rep1 ctx a) => Query1 ctx r -> a -> [r]
gmapM1 :: forall a ctx m. (Rep1 ctx a, Monad m) => MapM1 ctx m -> a -> m a
data Typed a
(:::) :: a -> R a -> Typed a
data Spine a
[Constr] :: a -> Spine a
[:<>] :: Spine (a -> b) -> Typed a -> Spine b
toSpine :: Rep a => a -> Spine a
fromSpine :: Spine a -> a
instance Data.Type.Equality.TestEquality Generics.RepLib.R.R
instance GHC.Classes.Eq Generics.RepLib.R.DT
instance GHC.Classes.Ord Generics.RepLib.R.DT


-- | The module PreludeLib contains generic operations to derive members of
--   the standard prelude classess: Eq, Bounded, Compare, Show (TODO: add
--   Enum and Read)
--   
--   Although these classes may already be automatically derived via the
--   "deriving" mechanism, this module is included for two reasons:
--   
--   <ul>
--   <li>Deriving only works when datatypes are defined. This library
--   allows instances of these classes to be generated anywhere. For
--   example, suppose some other module contains the definition of the
--   datatype T and exposes all of its constructors, but, frustratingly,
--   does not derive an instance of the Show class.</li>
--   </ul>
--   
--   You could define a Show instance of <tt>T</tt> in your own module with
--   the following code:
--   
--   <pre>
--   import RepLib
--   
--   (repr1 ''T)  -- make the Rep1 instance of T available
--   
--   instance Show T where
--     showsPrec = showsPrecR1 rep1   -- showsPrecR1 is defined in this module
--   </pre>
--   
--   <ul>
--   <li>This library also serves as a model for generic functions that are
--   slight modifications to these prelude operations. For example, if you
--   wanted to define reverse lexicographic ordering or an XML pretty
--   printer for datatypes, you might start here. This library is also a
--   good place to start learning how to define your own generic
--   operations, because the behavior of these operations should match the
--   deriving mechanism specified by Haskell 98.</li>
--   </ul>
module Generics.RepLib.PreludeLib
data EqD a

-- | Polymorphic equality, given an R1 representation
eqR1 :: R1 EqD a -> a -> a -> Bool
data OrdD a

-- | Minimal completion of the Ord class
compareR1 :: R1 OrdD a -> a -> a -> Ordering
data BoundedD a

-- | To generate the Bounded class
minBoundR1 :: R1 BoundedD a -> a

-- | To generate the Bounded class
maxBoundR1 :: R1 BoundedD a -> a
data ShowD a

-- | Minimal completion of the show class
showsPrecR1 :: R1 ShowD a -> Int -> a -> ShowS
instance GHC.Show.Show a => Generics.RepLib.R1.Sat (Generics.RepLib.PreludeLib.ShowD a)
instance GHC.Enum.Bounded a => Generics.RepLib.R1.Sat (Generics.RepLib.PreludeLib.BoundedD a)
instance GHC.Classes.Ord a => Generics.RepLib.R1.Sat (Generics.RepLib.PreludeLib.OrdD a)
instance GHC.Classes.Eq a => Generics.RepLib.R1.Sat (Generics.RepLib.PreludeLib.EqD a)


-- | A library of type-indexed functions
module Generics.RepLib.Lib

-- | Produce all children of a datastructure with the same type. Note that
--   subtrees is available for all representable types. For those that are
--   not recursive datatypes, subtrees will always return the empty list.
--   But, these trivial instances are convenient to have for the Shrink
--   operation below.
subtrees :: forall a. Rep a => a -> [a]

-- | Recursively force the evaluation of the first argument. For example,
--   <tt> deepSeq ( x , y ) z where x = ... y = ... </tt> will evaluate
--   both <tt>x</tt> and <tt>y</tt> then return <tt>z</tt>
deepSeq :: Rep a => a -> b -> b

-- | Force the evaluation of *datatypes* to their normal forms. Other types
--   are left alone and not forced.
rnf :: Rep a => a -> a

-- | Add together all of the <tt>Int</tt>s in a datastructure For example:
--   gsum ( 1 , True, ("a", Maybe 3, []) , Nothing) 4
class Rep1 GSumD a => GSum a
gsum :: GSum a => a -> Int

-- | Create a zero element of a type <tt> ( zero :: ((Int, Maybe Int),
--   Float)) ((0, Nothing), 0.0) </tt>
class (Rep1 ZeroD a) => Zero a
zero :: Zero a => a

-- | Generate elements of a type up to a certain depth
class Rep1 GenerateD a => Generate a
generate :: Generate a => Int -> [a]

-- | enumerate the elements of a type, in DFS order.
class Rep1 EnumerateD a => Enumerate a
enumerate :: Enumerate a => [a]

-- | Given an element, return smaller elements of the same type for
--   example, to automatically find small counterexamples when testing
class (Rep1 ShrinkD a) => Shrink a
shrink :: Shrink a => a -> [a]

-- | A general version of fold left, use for Fold class below
class Rep1 (LreduceD b) a => Lreduce b a
lreduce :: Lreduce b a => b -> a -> b

-- | A general version of fold right, use for Fold class below
class Rep1 (RreduceD b) a => Rreduce b a
rreduce :: Rreduce b a => a -> b -> b

-- | All of the functions below are defined using instances of the
--   following class
class Fold f
foldRight :: (Fold f, Rep a) => (a -> b -> b) -> f a -> b -> b
foldLeft :: (Fold f, Rep a) => (b -> a -> b) -> b -> f a -> b

-- | Fold a bindary operation left over a datastructure
crush :: (Rep a, Fold t) => (a -> a -> a) -> a -> t a -> a

-- | Multiply all elements together
gproduct :: (Rep a, Num a, Fold t) => t a -> a

-- | Ensure all booleans are true
gand :: (Fold t) => t Bool -> Bool

-- | Ensure at least one boolean is true
gor :: (Fold t) => t Bool -> Bool

-- | Convert to list
flatten :: (Rep a, Fold t) => t a -> [a]

-- | Count number of <tt>a</tt>s that appear in the argument
count :: (Rep a, Fold t) => t a -> Int

-- | Compose all functions in the datastructure together
comp :: (Rep a, Fold t) => t (a -> a) -> a -> a

-- | Concatenate all lists in the datastructure together
gconcat :: (Rep a, Fold t) => t [a] -> [a]

-- | Ensure property holds of all data
gall :: (Rep a, Fold t) => (a -> Bool) -> t a -> Bool

-- | Ensure property holds of some element
gany :: (Rep a, Fold t) => (a -> Bool) -> t a -> Bool

-- | Is an element stored in a datastructure
gelem :: (Rep a, Eq a, Fold t) => a -> t a -> Bool
data GSumD a
GSumD :: a -> Int -> GSumD a
[gsumD] :: GSumD a -> a -> Int
data ZeroD a
ZD :: a -> ZeroD a
[zeroD] :: ZeroD a -> a
data GenerateD a
GenerateD :: Int -> [a] -> GenerateD a
[generateD] :: GenerateD a -> Int -> [a]
data EnumerateD a
EnumerateD :: [a] -> EnumerateD a
[enumerateD] :: EnumerateD a -> [a]
data ShrinkD a
ShrinkD :: a -> [a] -> ShrinkD a
[shrinkD] :: ShrinkD a -> a -> [a]
data LreduceD b a
LreduceD :: b -> a -> b -> LreduceD b a
[lreduceD] :: LreduceD b a -> b -> a -> b
data RreduceD b a
RreduceD :: a -> b -> b -> RreduceD b a
[rreduceD] :: RreduceD b a -> a -> b -> b
rnfR :: R a -> a -> a
deepSeqR :: R a -> a -> b -> b
gsumR1 :: R1 GSumD a -> a -> Int
zeroR1 :: R1 ZeroD a -> a
generateR1 :: R1 GenerateD a -> Int -> [a]
enumerateR1 :: R1 EnumerateD a -> [a]
lreduceR1 :: R1 (LreduceD b) a -> b -> a -> b
rreduceR1 :: R1 (RreduceD b) a -> a -> b -> b
instance Generics.RepLib.Lib.Fold []
instance Generics.RepLib.Lib.Fold Data.Set.Internal.Set
instance Generics.RepLib.Lib.Fold (Data.Map.Internal.Map k)
instance Generics.RepLib.Lib.Lreduce b a => Generics.RepLib.R1.Sat (Generics.RepLib.Lib.LreduceD b a)
instance Generics.RepLib.Lib.Lreduce b GHC.Types.Int
instance Generics.RepLib.Lib.Lreduce b ()
instance Generics.RepLib.Lib.Lreduce b GHC.Types.Char
instance Generics.RepLib.Lib.Lreduce b GHC.Types.Bool
instance (Generics.RepLib.Lib.Lreduce c a, Generics.RepLib.Lib.Lreduce c b) => Generics.RepLib.Lib.Lreduce c (a, b)
instance Generics.RepLib.Lib.Lreduce c a => Generics.RepLib.Lib.Lreduce c [a]
instance (GHC.Classes.Ord a, Generics.RepLib.Lib.Lreduce b a) => Generics.RepLib.Lib.Lreduce b (Data.Set.Internal.Set a)
instance Generics.RepLib.Lib.Rreduce b a => Generics.RepLib.R1.Sat (Generics.RepLib.Lib.RreduceD b a)
instance Generics.RepLib.Lib.Rreduce b GHC.Types.Int
instance Generics.RepLib.Lib.Rreduce b ()
instance Generics.RepLib.Lib.Rreduce b GHC.Types.Char
instance Generics.RepLib.Lib.Rreduce b GHC.Types.Bool
instance (Generics.RepLib.Lib.Rreduce c a, Generics.RepLib.Lib.Rreduce c b) => Generics.RepLib.Lib.Rreduce c (a, b)
instance Generics.RepLib.Lib.Rreduce c a => Generics.RepLib.Lib.Rreduce c [a]
instance (GHC.Classes.Ord a, Generics.RepLib.Lib.Rreduce b a) => Generics.RepLib.Lib.Rreduce b (Data.Set.Internal.Set a)
instance Generics.RepLib.Lib.Shrink a => Generics.RepLib.R1.Sat (Generics.RepLib.Lib.ShrinkD a)
instance Generics.RepLib.Lib.Shrink GHC.Types.Int
instance Generics.RepLib.Lib.Shrink a => Generics.RepLib.Lib.Shrink [a]
instance Generics.RepLib.Lib.Shrink GHC.Types.Char
instance Generics.RepLib.Lib.Shrink ()
instance (Generics.RepLib.Lib.Shrink a, Generics.RepLib.Lib.Shrink b) => Generics.RepLib.Lib.Shrink (a, b)
instance (GHC.Classes.Ord a, Generics.RepLib.Lib.Shrink a) => Generics.RepLib.Lib.Shrink (Data.Set.Internal.Set a)
instance (GHC.Classes.Ord k, Generics.RepLib.Lib.Shrink k, Generics.RepLib.Lib.Shrink a) => Generics.RepLib.Lib.Shrink (Data.Map.Internal.Map k a)
instance GHC.Base.Functor Generics.RepLib.Lib.M
instance GHC.Base.Applicative Generics.RepLib.Lib.M
instance GHC.Base.Monad Generics.RepLib.Lib.M
instance Generics.RepLib.Lib.Enumerate a => Generics.RepLib.R1.Sat (Generics.RepLib.Lib.EnumerateD a)
instance Generics.RepLib.Lib.Enumerate GHC.Types.Int
instance Generics.RepLib.Lib.Enumerate GHC.Types.Char
instance Generics.RepLib.Lib.Enumerate GHC.Integer.Type.Integer
instance Generics.RepLib.Lib.Enumerate GHC.Types.Float
instance Generics.RepLib.Lib.Enumerate GHC.Types.Double
instance Generics.RepLib.Lib.Enumerate GHC.Types.Bool
instance Generics.RepLib.Lib.Enumerate ()
instance (Generics.RepLib.Lib.Enumerate a, Generics.RepLib.Lib.Enumerate b) => Generics.RepLib.Lib.Enumerate (a, b)
instance Generics.RepLib.Lib.Enumerate a => Generics.RepLib.Lib.Enumerate [a]
instance (GHC.Classes.Ord a, Generics.RepLib.Lib.Enumerate a) => Generics.RepLib.Lib.Enumerate (Data.Set.Internal.Set a)
instance (GHC.Classes.Ord k, Generics.RepLib.Lib.Enumerate k, Generics.RepLib.Lib.Enumerate a) => Generics.RepLib.Lib.Enumerate (Data.Map.Internal.Map k a)
instance Generics.RepLib.Lib.Generate a => Generics.RepLib.R1.Sat (Generics.RepLib.Lib.GenerateD a)
instance Generics.RepLib.Lib.Generate GHC.Types.Int
instance Generics.RepLib.Lib.Generate GHC.Types.Char
instance Generics.RepLib.Lib.Generate GHC.Integer.Type.Integer
instance Generics.RepLib.Lib.Generate GHC.Types.Float
instance Generics.RepLib.Lib.Generate GHC.Types.Double
instance Generics.RepLib.Lib.Generate ()
instance (Generics.RepLib.Lib.Generate a, Generics.RepLib.Lib.Generate b) => Generics.RepLib.Lib.Generate (a, b)
instance Generics.RepLib.Lib.Generate a => Generics.RepLib.Lib.Generate [a]
instance (GHC.Classes.Ord a, Generics.RepLib.Lib.Generate a) => Generics.RepLib.Lib.Generate (Data.Set.Internal.Set a)
instance (GHC.Classes.Ord k, Generics.RepLib.Lib.Generate k, Generics.RepLib.Lib.Generate a) => Generics.RepLib.Lib.Generate (Data.Map.Internal.Map k a)
instance Generics.RepLib.Lib.Zero a => Generics.RepLib.R1.Sat (Generics.RepLib.Lib.ZeroD a)
instance Generics.RepLib.Lib.Zero GHC.Types.Int
instance Generics.RepLib.Lib.Zero GHC.Types.Char
instance (Generics.RepLib.Lib.Zero a, Generics.RepLib.Lib.Zero b) => Generics.RepLib.Lib.Zero (a -> b)
instance Generics.RepLib.Lib.Zero GHC.Integer.Type.Integer
instance Generics.RepLib.Lib.Zero GHC.Types.Float
instance Generics.RepLib.Lib.Zero GHC.Types.Double
instance Generics.RepLib.Lib.Zero GHC.IO.Exception.IOError
instance Generics.RepLib.Lib.Zero ()
instance Generics.RepLib.Lib.Zero GHC.Types.Bool
instance (Generics.RepLib.Lib.Zero a, Generics.RepLib.Lib.Zero b) => Generics.RepLib.Lib.Zero (a, b)
instance Generics.RepLib.Lib.Zero a => Generics.RepLib.Lib.Zero [a]
instance (Generics.RepLib.R.Rep k, Generics.RepLib.R.Rep a) => Generics.RepLib.Lib.Zero (Data.Map.Internal.Map k a)
instance Generics.RepLib.R.Rep a => Generics.RepLib.Lib.Zero (Data.Set.Internal.Set a)
instance Generics.RepLib.Lib.GSum a => Generics.RepLib.R1.Sat (Generics.RepLib.Lib.GSumD a)
instance Generics.RepLib.Lib.GSum GHC.Types.Float
instance Generics.RepLib.Lib.GSum GHC.Types.Int
instance Generics.RepLib.Lib.GSum GHC.Types.Bool
instance Generics.RepLib.Lib.GSum ()
instance Generics.RepLib.Lib.GSum GHC.Integer.Type.Integer
instance Generics.RepLib.Lib.GSum GHC.Types.Char
instance Generics.RepLib.Lib.GSum GHC.Types.Double
instance (Generics.RepLib.Lib.GSum a, Generics.RepLib.Lib.GSum b) => Generics.RepLib.Lib.GSum (a, b)
instance Generics.RepLib.Lib.GSum a => Generics.RepLib.Lib.GSum [a]
instance (Generics.RepLib.R.Rep k, Generics.RepLib.Lib.GSum a) => Generics.RepLib.Lib.GSum (Data.Map.Internal.Map k a)
instance Generics.RepLib.Lib.GSum a => Generics.RepLib.Lib.GSum (Data.Set.Internal.Set a)


module Generics.RepLib.SYB.Aliases

-- | Make a generic transformation; start from a type-specific case;
--   preserve the term otherwise
mkT :: (Rep a, Rep b) => (b -> b) -> a -> a

-- | Make a generic query; start from a type-specific case; return a
--   constant otherwise
mkQ :: (Rep a, Rep b) => r -> (b -> r) -> a -> r

-- | Make a generic monadic transformation; start from a type-specific
--   case; resort to return otherwise
mkM :: (Monad m, Rep a, Rep b) => (b -> m b) -> a -> m a

-- | Make a generic monadic transformation for MonadPlus; use "const mzero"
--   (i.e., failure) instead of return as default.
mkMp :: (MonadPlus m, Rep a, Rep b) => (b -> m b) -> a -> m a

-- | Make a generic builder; start from a type-specific ase; resort to no
--   build (i.e., mzero) otherwise
mkR :: (MonadPlus m, Rep a, Rep b) => m b -> m a

-- | Flexible type extension
ext0 :: (Rep a, Rep b) => c a -> c b -> c a

-- | Extend a generic transformation by a type-specific case
extT :: (Rep a, Rep b) => (a -> a) -> (b -> b) -> a -> a

-- | Extend a generic query by a type-specific case
extQ :: (Rep a, Rep b) => (a -> q) -> (b -> q) -> a -> q

-- | Extend a generic monadic transformation by a type-specific case
extM :: (Monad m, Rep a, Rep b) => (a -> m a) -> (b -> m b) -> a -> m a

-- | Extend a generic MonadPlus transformation by a type-specific case
extMp :: (MonadPlus m, Rep a, Rep b) => (a -> m a) -> (b -> m b) -> a -> m a

-- | Extend a generic builder
extB :: (Rep a, Rep b) => a -> b -> a

-- | Extend a generic reader
extR :: (Monad m, Rep a, Rep b) => m a -> m b -> m a

-- | Generic transformations, i.e., take an "a" and return an "a"
type GenericT = forall a. Rep a => a -> a

-- | Generic queries of type "r", i.e., take any "a" and return an "r"
type GenericQ r = forall a. Rep a => a -> r

-- | Generic monadic transformations, i.e., take an "a" and compute an "a"
type GenericM m = forall a. Rep a => a -> m a

-- | Generic builders i.e., produce an "a".
type GenericB = forall a. Rep a => a

-- | Generic readers, say monadic builders, i.e., produce an "a" with the
--   help of a monad "m".
type GenericR m = forall a. Rep a => m a

-- | The general scheme underlying generic functions assumed by gfoldl;
--   there are isomorphisms such as GenericT = Generic T.
type Generic c = forall a. Rep a => a -> c a

-- | Wrapped generic functions; recall: [Generic c] would be legal but
--   [Generic' c] not.
data Generic' c
Generic' :: Generic c -> Generic' c
[unGeneric'] :: Generic' c -> Generic c

-- | Other first-class polymorphic wrappers
newtype GenericT'
GT :: forall a. Rep a => a -> a -> GenericT'
[unGT] :: GenericT' -> forall a. Rep a => a -> a
newtype GenericQ' r
GQ :: GenericQ r -> GenericQ' r
[unGQ] :: GenericQ' r -> GenericQ r
newtype GenericM' m
GM :: forall a. Rep a => a -> m a -> GenericM' m
[unGM] :: GenericM' m -> forall a. Rep a => a -> m a

-- | Left-biased choice on maybies
orElse :: Maybe a -> Maybe a -> Maybe a

-- | Recover from the failure of monadic transformation by identity
recoverMp :: MonadPlus m => GenericM m -> GenericM m

-- | Recover from the failure of monadic query by a constant
recoverQ :: MonadPlus m => r -> GenericQ (m r) -> GenericQ (m r)

-- | Choice for monadic transformations
choiceMp :: MonadPlus m => GenericM m -> GenericM m -> GenericM m

-- | Choice for monadic queries
choiceQ :: MonadPlus m => GenericQ (m r) -> GenericQ (m r) -> GenericQ (m r)


-- | Derived from Data.Generics.Schemes Only modification: <a>Data</a>
--   class becomes <a>Rep</a> class otherwise import our version of the
--   libraries For now, missing "somewhere" (lacking mapMp)
module Generics.RepLib.SYB.Schemes

-- | Apply a transformation everywhere in bottom-up manner
everywhere :: (forall a. Rep a => a -> a) -> (forall a. Rep a => a -> a)

-- | Apply a transformation everywhere in top-down manner
everywhere' :: (forall a. Rep a => a -> a) -> (forall a. Rep a => a -> a)

-- | Variation on everywhere with an extra stop condition
everywhereBut :: GenericQ Bool -> GenericT -> GenericT

-- | Monadic variation on everywhere
everywhereM :: Monad m => GenericM m -> GenericM m

-- | Apply a monadic transformation at least somewhere somewhere ::
--   MonadPlus m =&gt; GenericM m -&gt; GenericM m
--   
--   Summarise all nodes in top-down, left-to-right order
everything :: (r -> r -> r) -> GenericQ r -> GenericQ r

-- | Get a list of all entities that meet a predicate
listify :: Rep r => (r -> Bool) -> GenericQ [r]

-- | Look up a subterm by means of a maybe-typed filter
something :: GenericQ (Maybe u) -> GenericQ (Maybe u)

-- | Bottom-up synthesis of a data structure; 1st argument z is the initial
--   element for the synthesis; 2nd argument o is for reduction of results
--   from subterms; 3rd argument f updates the synthesised data according
--   to the given term
synthesize :: s -> (s -> s -> s) -> GenericQ (s -> s) -> GenericQ s

-- | Compute size of an arbitrary data structure
gsize :: Rep a => a -> Int

-- | Count the number of immediate subterms of the given term
glength :: GenericQ Int

-- | Determine depth of the given term
gdepth :: GenericQ Int

-- | Determine the number of all suitable nodes in a given term
gcount :: GenericQ Bool -> GenericQ Int

-- | Determine the number of all nodes in a given term
gnodecount :: GenericQ Int

-- | Determine the number of nodes of a given type in a given term
gtypecount :: Rep a => a -> GenericQ Int

-- | Find (unambiguously) an immediate subterm of a given type
gfindtype :: (Rep x, Rep y) => x -> Maybe y


module Generics.RepLib

-- | Propositional equality. If <tt>a :~: b</tt> is inhabited by some
--   terminating value, then the type <tt>a</tt> is the same as the type
--   <tt>b</tt>. To use this equality in practice, pattern-match on the
--   <tt>a :~: b</tt> to get out the <tt>Refl</tt> constructor; in the body
--   of the pattern-match, the compiler knows that <tt>a ~ b</tt>.
data (:~:) (a :: k) (b :: k) :: forall k. () => k -> k -> *
[Refl] :: a :~: a

-- | This class contains types where you can learn the equality of two
--   types from information contained in <i>terms</i>. Typically, only
--   singleton types should inhabit this class.
class TestEquality (f :: k -> *)

-- | Conditionally prove the equality of <tt>a</tt> and <tt>b</tt>.
testEquality :: TestEquality f => f a -> f b -> Maybe a :~: b

module Generics.RepLib.Unify
data Proxy a
type UnifyError = String
type UM n a b = ExceptT UnifyError (State (UnificationState n a)) b
throwError :: UnifyError -> UM n a b
data UnifySubD n a b
UnifySubD :: Proxy (n, a) -> b -> b -> UM n a () -> n -> a -> b -> b -> n -> Proxy a -> b -> Bool -> UnifySubD n a b
[unifyStepD] :: UnifySubD n a b -> Proxy (n, a) -> b -> b -> UM n a ()
[substD] :: UnifySubD n a b -> n -> a -> b -> b
[occursCheckD] :: UnifySubD n a b -> n -> Proxy a -> b -> Bool
data UConstraint n a
UC :: (UnifySubD n a b) -> b -> b -> UConstraint n a
data UnificationState n a
UState :: [UConstraint n a] -> [(n, a)] -> UnificationState n a
[uConstraints] :: UnificationState n a -> [UConstraint n a]
[uSubst] :: UnificationState n a -> [(n, a)]
class (Eq n, Show n, Show a, Show b, HasVar n a) => Unify n a b
unifyStep :: Unify n a b => Proxy (n, a) -> b -> b -> UM n a ()

-- | Generic unifyStep. almost identical to polymorphic equality
unifyStepR1 :: (Eq n, Show n, Show a, Show b, HasVar n a) => R1 (UnifySubD n a) b -> Proxy (n, a) -> b -> b -> UM n a ()
addConstraintsRL1 :: MTup (UnifySubD n a) l -> Proxy (n, a) -> l -> l -> UM n a ()
unifyStepEq :: (Eq b, Show b) => b -> b -> UM n a ()
dequeueConstraint :: UM n a (Maybe (UConstraint n a))
queueConstraint :: UConstraint n a -> UM n a ()
extendSubstitution :: (HasVar n a, Eq n, Show n, Show a, Rep1 (UnifySubD n a) a) => (n, a) -> UM n a ()
solveUnification :: (HasVar n a, Eq n, Show n, Show a, Rep1 (UnifySubD n a) a) => [(a, a)] -> Maybe [(n, a)]
solveUnification' :: (HasVar n a, Eq n, Show n, Show a, Show b, Rep1 (UnifySubD n a) b) => Proxy (n, a) -> [(b, b)] -> Maybe [(n, a)]
class HasVar a b
is_var :: HasVar a b => b -> Maybe a
var :: HasVar a b => a -> b
class Subst a t t'
subst :: Subst a t t' => a -> t -> t' -> t'
substR1 :: Rep1 (UnifySubD a t) t' => R1 (UnifySubD a t) t' -> a -> t -> t' -> t'
class Occurs n a b
occursCheck :: Occurs n a b => n -> Proxy a -> b -> Bool
occursCheckR1 :: Rep1 (UnifySubD n a) b => R1 (UnifySubD n a) b -> n -> Proxy a -> b -> Bool
instance (Generics.RepLib.Unify.Unify n a b, Generics.RepLib.Unify.Subst n a b, Generics.RepLib.Unify.Occurs n a b) => Generics.RepLib.R1.Sat (Generics.RepLib.Unify.UnifySubD n a b)
instance Generics.RepLib.R1.Rep1 (Generics.RepLib.Unify.UnifySubD n a) b => Generics.RepLib.Unify.Occurs n a b
instance (GHC.Classes.Eq n, Generics.RepLib.Unify.HasVar n a, Generics.RepLib.R1.Rep1 (Generics.RepLib.Unify.UnifySubD n a) a) => Generics.RepLib.Unify.Occurs n a a
instance Generics.RepLib.R1.Rep1 (Generics.RepLib.Unify.UnifySubD a t) t' => Generics.RepLib.Unify.Subst a t t'
instance (GHC.Classes.Eq a, Generics.RepLib.Unify.HasVar a t, Generics.RepLib.R1.Rep1 (Generics.RepLib.Unify.UnifySubD a t) t) => Generics.RepLib.Unify.Subst a t t
instance (GHC.Classes.Eq n, GHC.Show.Show n, GHC.Show.Show a, GHC.Show.Show b, Generics.RepLib.Unify.HasVar n a, Generics.RepLib.R1.Rep1 (Generics.RepLib.Unify.UnifySubD n a) b) => Generics.RepLib.Unify.Unify n a b
instance (GHC.Classes.Eq n, GHC.Show.Show n, GHC.Show.Show a, Generics.RepLib.Unify.HasVar n a, Generics.RepLib.R1.Rep1 (Generics.RepLib.Unify.UnifySubD n a) a) => Generics.RepLib.Unify.Unify n a a