-- 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.3.4


-- | 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 :: R a -> R (IO a)
Arrow :: R a -> R b -> R (a -> b)
Data :: DT -> [Con R a] -> R a
Abstract :: DT -> R a
Equal :: 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
(:+:) :: r a -> MTup r l -> MTup r (a :*: l)

-- | A class of representable types
class Rep a
rep :: Rep a => R a
rUnitEmb :: Emb Nil ()
rUnit :: R ()
rTup2 :: (Rep a, Rep b) => R (a, b)
rPairEmb :: Emb (a :*: (b :*: Nil)) (a, b)
rList :: 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 :: ctx a -> R1 ctx (IO a)
Arrow1 :: ctx a -> ctx b -> R1 ctx (a -> b)
Data1 :: DT -> [Con ctx a] -> R1 ctx a
Abstract1 :: DT -> R1 ctx a
Equal1 :: 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 :: (Rep a, Rep b) => ctx a -> ctx b -> R1 ctx (a, b)
rList1 :: Rep a => ctx a -> ctx [a] -> R1 ctx [a]
instance GHC.Show.Show (Generics.RepLib.R1.R1 c 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]


-- | 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 Control.Monad.Writer.Class.MonadWriter (Data.Set.Base.Set GHC.Types.Int) Generics.RepLib.Derive.QN
instance GHC.Base.Monad Generics.RepLib.Derive.QN
instance GHC.Base.Functor Generics.RepLib.Derive.QN
instance GHC.Base.Applicative 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 :: (Rep a_12, Rep b_13, Rep c_14, Rep d_15, Rep e_16, Rep f_17, Rep g_18) => (ctx_agot a_12, ctx_agot b_13, ctx_agot c_14, ctx_agot d_15, ctx_agot e_16, ctx_agot f_17, ctx_agot g_18) -> R1 ctx_agot ((,,,,,,) a_12 b_13 c_14 d_15 e_16 f_17 g_18)
rTup7 :: (Rep a_12, Rep b_13, Rep c_14, Rep d_15, Rep e_16, Rep f_17, Rep g_18) => R ((,,,,,,) a_12 b_13 c_14 d_15 e_16 f_17 g_18)
rTup6_1 :: (Rep a_12, Rep b_13, Rep c_14, Rep d_15, Rep e_16, Rep f_17) => (ctx_agnV a_12, ctx_agnV b_13, ctx_agnV c_14, ctx_agnV d_15, ctx_agnV e_16, ctx_agnV f_17) -> R1 ctx_agnV ((,,,,,) a_12 b_13 c_14 d_15 e_16 f_17)
rTup6 :: (Rep a_12, Rep b_13, Rep c_14, Rep d_15, Rep e_16, Rep f_17) => R ((,,,,,) a_12 b_13 c_14 d_15 e_16 f_17)
rTup5_1 :: (Rep a_12, Rep b_13, Rep c_14, Rep d_15, Rep e_16) => (ctx_agns a_12, ctx_agns b_13, ctx_agns c_14, ctx_agns d_15, ctx_agns e_16) -> R1 ctx_agns ((,,,,) a_12 b_13 c_14 d_15 e_16)
rTup5 :: (Rep a_12, Rep b_13, Rep c_14, Rep d_15, Rep e_16) => R ((,,,,) a_12 b_13 c_14 d_15 e_16)
rTup4_1 :: (Rep a_12, Rep b_13, Rep c_14, Rep d_15) => (ctx_agn4 a_12, ctx_agn4 b_13, ctx_agn4 c_14, ctx_agn4 d_15) -> R1 ctx_agn4 ((,,,) a_12 b_13 c_14 d_15)
rTup4 :: (Rep a_12, Rep b_13, Rep c_14, Rep d_15) => R ((,,,) a_12 b_13 c_14 d_15)
rTup3_1 :: (Rep a_12, Rep b_13, Rep c_14) => (ctx_agmL a_12, ctx_agmL b_13, ctx_agmL c_14) -> R1 ctx_agmL ((,,) a_12 b_13 c_14)
rTup3 :: (Rep a_12, Rep b_13, Rep c_14) => R ((,,) a_12 b_13 c_14)
rOrdering1 :: () -> () -> () -> R1 ctx_agmB Ordering
rOrdering :: R Ordering
rEither1 :: (Rep a_agma, Rep b_agmb) => ctx_agmk a_agma -> ctx_agmk b_agmb -> R1 ctx_agmk (Either a_agma b_agmb)
rEither :: (Rep a_agma, Rep b_agmb) => R (Either a_agma b_agmb)
rMaybe1 :: Rep a_a2Zv => () -> ctx_aglY a_a2Zv -> R1 ctx_aglY (Maybe a_a2Zv)
rMaybe :: Rep a_a2Zv => R (Maybe a_a2Zv)
rBool1 :: () -> () -> R1 ctx_aglR Bool
rBool :: R Bool
instance Generics.RepLib.R.Rep GHC.Types.Bool
instance Generics.RepLib.R1.Rep1 ctx0 GHC.Types.Bool
instance Generics.RepLib.R.Rep a0 => Generics.RepLib.R.Rep (GHC.Base.Maybe a0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R1.Sat (ctx0 a0)) => Generics.RepLib.R1.Rep1 ctx0 (GHC.Base.Maybe a0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0) => Generics.RepLib.R.Rep (Data.Either.Either a0 b0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R1.Sat (ctx0 a0), Generics.RepLib.R1.Sat (ctx0 b0)) => Generics.RepLib.R1.Rep1 ctx0 (Data.Either.Either a0 b0)
instance Generics.RepLib.R.Rep GHC.Types.Ordering
instance Generics.RepLib.R1.Rep1 ctx0 GHC.Types.Ordering
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0) => Generics.RepLib.R.Rep (a0, b0, c0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0, Generics.RepLib.R1.Sat (ctx0 a0), Generics.RepLib.R1.Sat (ctx0 b0), Generics.RepLib.R1.Sat (ctx0 c0)) => Generics.RepLib.R1.Rep1 ctx0 (a0, b0, c0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0, Generics.RepLib.R.Rep d0) => Generics.RepLib.R.Rep (a0, b0, c0, d0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0, Generics.RepLib.R.Rep d0, Generics.RepLib.R1.Sat (ctx0 a0), Generics.RepLib.R1.Sat (ctx0 b0), Generics.RepLib.R1.Sat (ctx0 c0), Generics.RepLib.R1.Sat (ctx0 d0)) => Generics.RepLib.R1.Rep1 ctx0 (a0, b0, c0, d0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0, Generics.RepLib.R.Rep d0, Generics.RepLib.R.Rep e0) => Generics.RepLib.R.Rep (a0, b0, c0, d0, e0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0, Generics.RepLib.R.Rep d0, Generics.RepLib.R.Rep e0, Generics.RepLib.R1.Sat (ctx0 a0), Generics.RepLib.R1.Sat (ctx0 b0), Generics.RepLib.R1.Sat (ctx0 c0), Generics.RepLib.R1.Sat (ctx0 d0), Generics.RepLib.R1.Sat (ctx0 e0)) => Generics.RepLib.R1.Rep1 ctx0 (a0, b0, c0, d0, e0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0, Generics.RepLib.R.Rep d0, Generics.RepLib.R.Rep e0, Generics.RepLib.R.Rep f0) => Generics.RepLib.R.Rep (a0, b0, c0, d0, e0, f0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0, Generics.RepLib.R.Rep d0, Generics.RepLib.R.Rep e0, Generics.RepLib.R.Rep f0, Generics.RepLib.R1.Sat (ctx0 a0), Generics.RepLib.R1.Sat (ctx0 b0), Generics.RepLib.R1.Sat (ctx0 c0), Generics.RepLib.R1.Sat (ctx0 d0), Generics.RepLib.R1.Sat (ctx0 e0), Generics.RepLib.R1.Sat (ctx0 f0)) => Generics.RepLib.R1.Rep1 ctx0 (a0, b0, c0, d0, e0, f0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0, Generics.RepLib.R.Rep d0, Generics.RepLib.R.Rep e0, Generics.RepLib.R.Rep f0, Generics.RepLib.R.Rep g0) => Generics.RepLib.R.Rep (a0, b0, c0, d0, e0, f0, g0)
instance (Generics.RepLib.R.Rep a0, Generics.RepLib.R.Rep b0, Generics.RepLib.R.Rep c0, Generics.RepLib.R.Rep d0, Generics.RepLib.R.Rep e0, Generics.RepLib.R.Rep f0, Generics.RepLib.R.Rep g0, Generics.RepLib.R1.Sat (ctx0 a0), Generics.RepLib.R1.Sat (ctx0 b0), Generics.RepLib.R1.Sat (ctx0 c0), Generics.RepLib.R1.Sat (ctx0 d0), Generics.RepLib.R1.Sat (ctx0 e0), Generics.RepLib.R1.Sat (ctx0 f0), Generics.RepLib.R1.Sat (ctx0 g0)) => Generics.RepLib.R1.Rep1 ctx0 (a0, b0, c0, d0, e0, f0, g0)


-- | 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 :: (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 :: (Rep a, Rep b) => c a -> Maybe (c b)

-- | Leibniz equality between types, explicit representations
gcastR :: 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 :: Rep a => Traversal -> a -> a
gmapQ :: Rep a => Query r -> a -> [r]
gmapM :: (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 :: (Rep1 ctx a) => Traversal1 ctx -> a -> a
gmapQ1 :: (Rep1 ctx a) => Query1 ctx r -> a -> [r]
gmapM1 :: (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


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


-- | 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.Classes.Eq a => Generics.RepLib.R1.Sat (Generics.RepLib.PreludeLib.EqD a)
instance GHC.Classes.Ord a => Generics.RepLib.R1.Sat (Generics.RepLib.PreludeLib.OrdD a)
instance GHC.Enum.Bounded a => Generics.RepLib.R1.Sat (Generics.RepLib.PreludeLib.BoundedD a)
instance GHC.Show.Show a => Generics.RepLib.R1.Sat (Generics.RepLib.PreludeLib.ShowD a)


-- | Abstract Reps for Common Abstract Datatypes
module Generics.RepLib.AbstractReps
rSet1 :: Rep a_a9wy => R1 ctx_amZQ (Set a_a9wy)
rSet :: Rep a_a9wy => R (Set a_a9wy)
rMap1 :: (Rep k_amZs, Rep a_amZt) => R1 ctx_amZC (Map k_amZs a_amZt)
rMap :: (Rep k_amZs, Rep a_amZt) => R (Map k_amZs a_amZt)
instance (Generics.RepLib.R.Rep k0, Generics.RepLib.R.Rep a0) => Generics.RepLib.R.Rep (Data.Map.Base.Map k0 a0)
instance (Generics.RepLib.R.Rep k0, Generics.RepLib.R.Rep a0) => Generics.RepLib.R1.Rep1 ctx0 (Data.Map.Base.Map k0 a0)
instance Generics.RepLib.R.Rep a0 => Generics.RepLib.R.Rep (Data.Set.Base.Set a0)
instance Generics.RepLib.R.Rep a0 => Generics.RepLib.R1.Rep1 ctx0 (Data.Set.Base.Set a0)


-- | 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 :: 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 where gsum = gsumR1 rep1
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 where zero = zeroR1 rep1
zero :: Zero a => a

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

-- | enumerate the elements of a type, in DFS order.
class Rep1 EnumerateD a => Enumerate a where enumerate = enumerateR1 rep1
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 where shrink a = subtrees a ++ shrinkStep a where shrinkStep _t = let M _ ts = gmapM1 m a in ts m :: forall b. ShrinkD b -> b -> M b m d x = M x (shrinkD d x)
shrink :: Shrink a => a -> [a]

-- | A general version of fold left, use for Fold class below
class Rep1 (LreduceD b) a => Lreduce b a where lreduce = lreduceR1 rep1
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 where rreduce = rreduceR1 rep1
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.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.Base.Map k a)
instance Generics.RepLib.Lib.GSum a => Generics.RepLib.Lib.GSum (Data.Set.Base.Set 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.Base.Map k a)
instance Generics.RepLib.R.Rep a => Generics.RepLib.Lib.Zero (Data.Set.Base.Set 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.Base.Set a)
instance (GHC.Classes.Ord k, Generics.RepLib.Lib.Generate k, Generics.RepLib.Lib.Generate a) => Generics.RepLib.Lib.Generate (Data.Map.Base.Map k a)
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.Base.Set a)
instance (GHC.Classes.Ord k, Generics.RepLib.Lib.Enumerate k, Generics.RepLib.Lib.Enumerate a) => Generics.RepLib.Lib.Enumerate (Data.Map.Base.Map k a)
instance Generics.RepLib.Lib.Shrink a => Generics.RepLib.R1.Sat (Generics.RepLib.Lib.ShrinkD 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.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.Base.Set a)
instance (GHC.Classes.Ord k, Generics.RepLib.Lib.Shrink k, Generics.RepLib.Lib.Shrink a) => Generics.RepLib.Lib.Shrink (Data.Map.Base.Map k a)
instance Generics.RepLib.Lib.Rreduce b a => Generics.RepLib.R1.Sat (Generics.RepLib.Lib.RreduceD b a)
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.Base.Set 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.Base.Set a)
instance Generics.RepLib.Lib.Fold []
instance Generics.RepLib.Lib.Fold Data.Set.Base.Set
instance Generics.RepLib.Lib.Fold (Data.Map.Base.Map k)

module Generics.RepLib.Unify
data Proxy a
type UnifyError = String
type UM n a b = ExceptT UnifyError (State (UnificationState 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 (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
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 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


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) :: k -> k -> *
Refl :: (:~:) k b b

-- | 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 ((:~:) k a b)