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


-- | Scrap Your Boilerplate With Class
--   
--   Classes, and Template Haskell code to generate instances, for the
--   Scrap Your Boilerplate With Class system.
@package syb-with-class
@version 0.6.1.10

module Data.Generics.SYB.WithClass.Context
class Sat a
dict :: Sat a => a
data NoCtx a
noCtx :: NoCtx ()
data PairCtx l r a
PairCtx :: l a -> r a -> PairCtx l r a
[leftCtx] :: PairCtx l r a -> l a
[rightCtx] :: PairCtx l r a -> r a
pairCtx :: l () -> r () -> PairCtx l r ()
instance (Data.Generics.SYB.WithClass.Context.Sat (l a), Data.Generics.SYB.WithClass.Context.Sat (r a)) => Data.Generics.SYB.WithClass.Context.Sat (Data.Generics.SYB.WithClass.Context.PairCtx l r a)
instance Data.Generics.SYB.WithClass.Context.Sat (Data.Generics.SYB.WithClass.Context.NoCtx a)

module Data.Generics.SYB.WithClass.Basics

-- | The class <a>Typeable</a> allows a concrete representation of a type
--   to be calculated.
class Typeable (a :: k)
data TyCon
typeOf7 :: Typeable t => t a b c d e f g -> TypeRep
typeOf6 :: Typeable t => t a b c d e f -> TypeRep
typeOf5 :: Typeable t => t a b c d e -> TypeRep
typeOf4 :: Typeable t => t a b c d -> TypeRep
typeOf3 :: Typeable t => t a b c -> TypeRep
typeOf2 :: Typeable t => t a b -> TypeRep
typeOf1 :: Typeable t => t a -> TypeRep

-- | Force a <a>TypeRep</a> to normal form.
rnfTypeRep :: TypeRep -> ()

-- | Takes a value of type <tt>a</tt> and returns a concrete representation
--   of that type.
typeRepFingerprint :: TypeRep -> Fingerprint

-- | Observe the type constructor of a quantified type representation.
typeRepTyCon :: TypeRep -> TyCon

-- | Observe the argument types of a type representation
typeRepArgs :: TypeRep -> [TypeRep]

-- | Splits a type constructor application. Note that if the type
--   constructor is polymorphic, this will not return the kinds that were
--   used.
splitTyConApp :: TypeRep -> (TyCon, [TypeRep])

-- | Build a function type.
mkFunTy :: TypeRep -> TypeRep -> TypeRep

-- | Applies a type to a function type. Returns: <tt>Just u</tt> if the
--   first argument represents a function of type <tt>t -&gt; u</tt> and
--   the second argument represents a function of type <tt>t</tt>.
--   Otherwise, returns <tt>Nothing</tt>.
funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep

-- | Cast over <tt>k1 -&gt; k2 -&gt; k3</tt>
gcast2 :: (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))

-- | Cast over <tt>k1 -&gt; k2</tt>
gcast1 :: (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))

-- | A flexible variation parameterised in a type constructor
gcast :: (Typeable a, Typeable b) => c a -> Maybe (c b)

-- | Extract a witness of equality of two types
eqT :: (Typeable a, Typeable b) => Maybe (a :~: b)

-- | The type-safe cast operation
cast :: (Typeable a, Typeable b) => a -> Maybe b

-- | Show a type representation
showsTypeRep :: TypeRep -> ShowS

-- | Takes a value of type <tt>a</tt> and returns a concrete representation
--   of that type.
typeRep :: Typeable a => proxy a -> TypeRep

-- | Observe a type representation for the type of a value.
typeOf :: Typeable a => a -> TypeRep

-- | A quantified type representation.
type TypeRep = SomeTypeRep
rnfTyCon :: TyCon -> ()
tyConFingerprint :: TyCon -> Fingerprint
tyConName :: TyCon -> String
tyConModule :: TyCon -> String
tyConPackage :: TyCon -> String

-- | 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 -> Type
[Refl] :: forall k (a :: k) (b :: k). () => a :~: a
infix 4 :~:

-- | Kind heterogeneous propositional equality. Like <a>:~:</a>, <tt>a :~~:
--   b</tt> is inhabited by a terminating value if and only if <tt>a</tt>
--   is the same type as <tt>b</tt>.
data (:~~:) (a :: k1) (b :: k2) :: forall k1 k2. () => k1 -> k2 -> Type
[HRefl] :: forall k1 k2 (a :: k1) (b :: k2). () => a :~~: a
infix 4 :~~:

-- | Fixity of constructors
data Fixity
Prefix :: Fixity
Infix :: Fixity

-- | Unique index for datatype constructors. | Textual order is respected.
--   Starts at 1.
type ConIndex = Int

-- | Public representation of constructors
data ConstrRep
AlgConstr :: ConIndex -> ConstrRep
IntConstr :: Integer -> ConstrRep
FloatConstr :: Double -> ConstrRep
StringConstr :: String -> ConstrRep

-- | Public representation of datatypes
data DataRep
AlgRep :: [Constr] -> DataRep
IntRep :: DataRep
FloatRep :: DataRep
StringRep :: DataRep
NoRep :: DataRep

-- | Representation of constructors
data Constr
Constr :: ConstrRep -> String -> [String] -> Fixity -> DataType -> Constr
[conrep] :: Constr -> ConstrRep
[constring] :: Constr -> String
[confields] :: Constr -> [String]
[confixity] :: Constr -> Fixity
[datatype] :: Constr -> DataType

-- | Representation of datatypes. | A package of constructor
--   representations with names of type and module. | The list of
--   constructors could be an array, a balanced tree, or others.
data DataType
DataType :: String -> DataRep -> DataType
[tycon] :: DataType -> String
[datarep] :: DataType -> DataRep
newtype Qr r a
Qr :: (r -> r) -> Qr r a
[unQr] :: Qr r a -> r -> r
type GenericQ ctx r = forall a. Data ctx a => a -> r
type GenericM m ctx = forall a. Data ctx a => a -> m a
newtype ID x
ID :: x -> ID x
[unID] :: ID x -> x
type GenericT ctx = forall a. Data ctx a => a -> a
class (Typeable a, Sat (ctx a)) => Data ctx a
gfoldl :: Data ctx a => Proxy ctx -> (forall b c. Data ctx b => w (b -> c) -> b -> w c) -> (forall g. g -> w g) -> a -> w a
gunfold :: Data ctx a => Proxy ctx -> (forall b r. Data ctx b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c a
toConstr :: Data ctx a => Proxy ctx -> a -> Constr
dataTypeOf :: Data ctx a => Proxy ctx -> a -> DataType

-- | Mediate types and unary type constructors
dataCast1 :: (Data ctx a, Typeable t) => Proxy ctx -> (forall b. Data ctx b => w (t b)) -> Maybe (w a)

-- | Mediate types and binary type constructors
dataCast2 :: (Data ctx a, Typeable t) => Proxy ctx -> (forall b c. (Data ctx b, Data ctx c) => w (t b c)) -> Maybe (w a)
data Proxy (a :: * -> *)
gmapT :: Proxy ctx -> GenericT ctx -> GenericT ctx
gmapM :: Monad m => Proxy ctx -> GenericM m ctx -> GenericM m ctx
gmapQ :: Proxy ctx -> GenericQ ctx r -> GenericQ ctx [r]
gmapQr :: Data ctx a => Proxy ctx -> (r' -> r -> r) -> r -> GenericQ ctx r' -> a -> r

-- | Build a term skeleton
fromConstr :: Data ctx a => Proxy ctx -> Constr -> a

-- | Build a term and use a generic function for subterms
fromConstrB :: Data ctx a => Proxy ctx -> (forall b. Data ctx b => b) -> Constr -> a

-- | Monadic variation on "fromConstrB"
fromConstrM :: (Monad m, Data ctx a) => Proxy ctx -> (forall b. Data ctx b => m b) -> Constr -> m a

-- | Gets the type constructor including the module
dataTypeName :: DataType -> String

-- | Gets the public presentation of datatypes
dataTypeRep :: DataType -> DataRep

-- | Gets the datatype of a constructor
constrType :: Constr -> DataType

-- | Gets the public presentation of constructors
constrRep :: Constr -> ConstrRep

-- | Look up a constructor by its representation
repConstr :: DataType -> ConstrRep -> Constr

-- | Constructs an algebraic datatype
mkDataType :: String -> [Constr] -> DataType

-- | Constructs a constructor
mkConstr :: DataType -> String -> [String] -> Fixity -> Constr

-- | Gets the constructors
dataTypeConstrs :: DataType -> [Constr]

-- | Gets the field labels of a constructor
constrFields :: Constr -> [String]

-- | Gets the fixity of a constructor
constrFixity :: Constr -> Fixity

-- | Gets the string for a constructor
showConstr :: Constr -> String

-- | Lookup a constructor via a string
readConstr :: DataType -> String -> Maybe Constr

-- | Test for an algebraic type
isAlgType :: DataType -> Bool

-- | Gets the constructor for an index
indexConstr :: DataType -> ConIndex -> Constr

-- | Gets the index of a constructor
constrIndex :: Constr -> ConIndex

-- | Gets the maximum constructor index
maxConstrIndex :: DataType -> ConIndex

-- | Constructs the Int type
mkIntType :: String -> DataType

-- | Constructs the Float type
mkFloatType :: String -> DataType

-- | Constructs the String type
mkStringType :: String -> DataType

-- | Helper for mkIntType, mkFloatType, mkStringType
mkPrimType :: DataRep -> String -> DataType
mkPrimCon :: DataType -> String -> ConstrRep -> Constr
mkIntConstr :: DataType -> Integer -> Constr
mkFloatConstr :: DataType -> Double -> Constr
mkStringConstr :: DataType -> String -> Constr

-- | Constructs a non-representation
mkNorepType :: String -> DataType

-- | Test for a non-representable type
isNorepType :: DataType -> Bool
instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.DataRep
instance GHC.Classes.Eq Data.Generics.SYB.WithClass.Basics.DataRep
instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.DataType
instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.Fixity
instance GHC.Classes.Eq Data.Generics.SYB.WithClass.Basics.Fixity
instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.ConstrRep
instance GHC.Classes.Eq Data.Generics.SYB.WithClass.Basics.ConstrRep
instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.Constr
instance GHC.Classes.Eq Data.Generics.SYB.WithClass.Basics.Constr

module Data.Generics.SYB.WithClass.Derive

-- | Takes the name of an algebraic data type, the number of type
--   parameters it has and creates a Typeable instance for it.
deriveTypeablePrim :: Name -> Int -> Q [Dec]
type Constructor = (Name, Int, Maybe [Name], [Type])
escape :: String -> String

-- | Takes a name of a algebraic data type, the number of parameters it has
--   and a list of constructor pairs. Each one of these constructor pairs
--   consists of a constructor name and the number of type parameters it
--   has. The function returns an automatically generated instance
--   declaration for the Data class.
--   
--   Doesn't do gunfold, dataCast1 or dataCast2
deriveDataPrim :: Name -> [Type] -> [Constructor] -> Q [Dec]
deriveMinimalData :: Name -> Int -> Q [Dec]
typeInfo :: Dec -> Q (Name, [Name], [Constructor])

-- | Derives the Data and Typeable instances for a single given data type.
deriveOne :: Name -> Q [Dec]
deriveOneDec :: Dec -> Q [Dec]
deriveOneData :: Name -> Q [Dec]

-- | Derives Data and Typeable instances for a list of data types. Order is
--   irrelevant. This should be used in favour of deriveOne since Data and
--   Typeable instances can often depend on other Data and Typeable
--   instances - e.g. if you are deriving a large, mutually recursive data
--   type. If you splice the derived instances in one by one you will need
--   to do it in depedency order which is difficult in most cases and
--   impossible in the mutually recursive case. It is better to bring all
--   the instances into scope at once.
--   
--   e.g. if data Foo = Foo Int is declared in an imported module then
--   $(derive [''Foo]) will derive the instances for it
derive :: [Name] -> Q [Dec]
deriveDec :: [Dec] -> Q [Dec]
deriveData :: [Name] -> Q [Dec]
deriveTypeable :: [Name] -> Q [Dec]
deriveOneTypeable :: Name -> Q [Dec]

-- | This function is much like deriveOne except that it brings into scope
--   an instance of Data with minimal definitions. gfoldl will essentially
--   leave a data structure untouched while gunfoldl, toConstr and
--   dataTypeOf will yield errors.
--   
--   This function is useful when you are certain that you will never wish
--   to transform a particular data type. For instance you may be
--   transforming another data type that contains other data types, some of
--   which you wish to transform (perhaps recursively) and some which you
--   just wish to return unchanged.
--   
--   Sometimes you will be forced to use deriveMinimalOne because you do
--   not have access to the contructors of the data type (perhaps because
--   it is an Abstract Data Type). However, should the interface to the ADT
--   be sufficiently rich it is possible to define you're own Data and
--   Typeable instances.
deriveMinimalOne :: Name -> Q [Dec]
deriveMinimal :: [Name] -> Q [Dec]

module Data.Generics.SYB.WithClass.Instances
instance (Data.Generics.SYB.WithClass.Basics.Data ctx Data.ByteString.Internal.ByteString, Data.Generics.SYB.WithClass.Context.Sat (ctx Data.ByteString.Lazy.Internal.ByteString), Data.Generics.SYB.WithClass.Context.Sat (ctx Data.ByteString.Internal.ByteString)) => Data.Generics.SYB.WithClass.Basics.Data ctx Data.ByteString.Lazy.Internal.ByteString
instance (Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.ForeignPtr.ForeignPtr GHC.Word.Word8), Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Int, Data.Generics.SYB.WithClass.Context.Sat (ctx Data.ByteString.Internal.ByteString), Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.ForeignPtr.ForeignPtr GHC.Word.Word8)), Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Int)) => Data.Generics.SYB.WithClass.Basics.Data ctx Data.ByteString.Internal.ByteString
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Bool) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Bool
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Char) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Char
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Float) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Float
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Double) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Double
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Int) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Int
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Integer.Type.Integer) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Integer.Type.Integer
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Int.Int8) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Int.Int8
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Int.Int16) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Int.Int16
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Int.Int32) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Int.Int32
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Int.Int64) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Int.Int64
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Word) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Word
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Word.Word8) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Word.Word8
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Word.Word16) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Word.Word16
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Word.Word32) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Word.Word32
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Word.Word64) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Word.Word64
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.Real.Ratio a)), Data.Generics.SYB.WithClass.Basics.Data ctx a, GHC.Real.Integral a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.Real.Ratio a)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx [a]), Data.Generics.SYB.WithClass.Basics.Data ctx a) => Data.Generics.SYB.WithClass.Basics.Data ctx [a]
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.Maybe.Maybe a)), Data.Generics.SYB.WithClass.Basics.Data ctx a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.Maybe.Maybe a)
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Ordering) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Ordering
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (Data.Either.Either a b)), Data.Generics.SYB.WithClass.Basics.Data ctx a, Data.Generics.SYB.WithClass.Basics.Data ctx b) => Data.Generics.SYB.WithClass.Basics.Data ctx (Data.Either.Either a b)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (a -> b)), Data.Generics.SYB.WithClass.Basics.Data ctx a, Data.Generics.SYB.WithClass.Basics.Data ctx b) => Data.Generics.SYB.WithClass.Basics.Data ctx (a -> b)
instance Data.Generics.SYB.WithClass.Context.Sat (ctx ()) => Data.Generics.SYB.WithClass.Basics.Data ctx ()
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (a, b)), Data.Generics.SYB.WithClass.Basics.Data ctx a, Data.Generics.SYB.WithClass.Basics.Data ctx b) => Data.Generics.SYB.WithClass.Basics.Data ctx (a, b)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (a, b, c)), Data.Generics.SYB.WithClass.Basics.Data ctx a, Data.Generics.SYB.WithClass.Basics.Data ctx b, Data.Generics.SYB.WithClass.Basics.Data ctx c) => Data.Generics.SYB.WithClass.Basics.Data ctx (a, b, c)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (a, b, c, d)), Data.Generics.SYB.WithClass.Basics.Data ctx a, Data.Generics.SYB.WithClass.Basics.Data ctx b, Data.Generics.SYB.WithClass.Basics.Data ctx c, Data.Generics.SYB.WithClass.Basics.Data ctx d) => Data.Generics.SYB.WithClass.Basics.Data ctx (a, b, c, d)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (a, b, c, d, e)), Data.Generics.SYB.WithClass.Basics.Data ctx a, Data.Generics.SYB.WithClass.Basics.Data ctx b, Data.Generics.SYB.WithClass.Basics.Data ctx c, Data.Generics.SYB.WithClass.Basics.Data ctx d, Data.Generics.SYB.WithClass.Basics.Data ctx e) => Data.Generics.SYB.WithClass.Basics.Data ctx (a, b, c, d, e)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (a, b, c, d, e, f)), Data.Generics.SYB.WithClass.Basics.Data ctx a, Data.Generics.SYB.WithClass.Basics.Data ctx b, Data.Generics.SYB.WithClass.Basics.Data ctx c, Data.Generics.SYB.WithClass.Basics.Data ctx d, Data.Generics.SYB.WithClass.Basics.Data ctx e, Data.Generics.SYB.WithClass.Basics.Data ctx f) => Data.Generics.SYB.WithClass.Basics.Data ctx (a, b, c, d, e, f)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (a, b, c, d, e, f, g)), Data.Generics.SYB.WithClass.Basics.Data ctx a, Data.Generics.SYB.WithClass.Basics.Data ctx b, Data.Generics.SYB.WithClass.Basics.Data ctx c, Data.Generics.SYB.WithClass.Basics.Data ctx d, Data.Generics.SYB.WithClass.Basics.Data ctx e, Data.Generics.SYB.WithClass.Basics.Data ctx f, Data.Generics.SYB.WithClass.Basics.Data ctx g) => Data.Generics.SYB.WithClass.Basics.Data ctx (a, b, c, d, e, f, g)
instance Data.Generics.SYB.WithClass.Context.Sat (ctx Data.Typeable.TypeRep) => Data.Generics.SYB.WithClass.Basics.Data ctx Data.Typeable.TypeRep
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.TyCon) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.TyCon
instance Data.Generics.SYB.WithClass.Context.Sat (ctx Data.Generics.SYB.WithClass.Basics.DataType) => Data.Generics.SYB.WithClass.Basics.Data ctx Data.Generics.SYB.WithClass.Basics.DataType
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.Types.IO a)), Data.Typeable.Internal.Typeable a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.Types.IO a)
instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.IO.Handle.Types.Handle) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.IO.Handle.Types.Handle
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.Ptr.Ptr a)), Data.Typeable.Internal.Typeable a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.Ptr.Ptr a)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.Stable.StablePtr a)), Data.Typeable.Internal.Typeable a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.Stable.StablePtr a)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.IORef.IORef a)), Data.Typeable.Internal.Typeable a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.IORef.IORef a)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.ForeignPtr.ForeignPtr a)), Data.Typeable.Internal.Typeable a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.ForeignPtr.ForeignPtr a)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.ST.ST s a)), Data.Typeable.Internal.Typeable s, Data.Typeable.Internal.Typeable a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.ST.ST s a)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.MVar.MVar a)), Data.Typeable.Internal.Typeable a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.MVar.MVar a)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx [b]), Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.Arr.Array a b)), Data.Typeable.Internal.Typeable a, Data.Generics.SYB.WithClass.Basics.Data ctx b, Data.Generics.SYB.WithClass.Basics.Data ctx [b], GHC.Arr.Ix a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.Arr.Array a b)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (Data.Map.Internal.Map a b)), Data.Generics.SYB.WithClass.Basics.Data ctx a, Data.Generics.SYB.WithClass.Basics.Data ctx b, GHC.Classes.Ord a) => Data.Generics.SYB.WithClass.Basics.Data ctx (Data.Map.Internal.Map a b)
instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (Data.Set.Internal.Set a)), Data.Generics.SYB.WithClass.Basics.Data ctx a, GHC.Classes.Ord a) => Data.Generics.SYB.WithClass.Basics.Data ctx (Data.Set.Internal.Set a)
