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


-- | (C) 2004 Ralf Laemmel
--   
--   Context parameterisation and context passing.
module Data.Generics.SYB.WithClass.Context

-- | The Sat class from John Hughes' "Restricted Data Types in Haskell"
class Sat a
dict :: Sat a => a

-- | No context
data NoCtx a
noCtx :: NoCtx ()

-- | Pair context
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)


-- | (C) 2004--2005 Ralf Laemmel, Simon D. Foster
--   
--   This module approximates Data.Generics.Basics.
module Data.Generics.SYB.WithClass.Basics
class Typeable (a :: k)
data TyCon
cast :: (Typeable a, Typeable b) => a -> Maybe b
eqT :: forall k (a :: k) (b :: k). (Typeable a, Typeable b) => Maybe (a :~: b)
funResultTy :: TypeRep -> TypeRep -> Maybe TypeRep
gcast :: forall k (a :: k) (b :: k) c. (Typeable a, Typeable b) => c a -> Maybe (c b)
gcast1 :: forall k1 k2 c (t :: k2 -> k1) (t' :: k2 -> k1) (a :: k2). (Typeable t, Typeable t') => c (t a) -> Maybe (c (t' a))
gcast2 :: forall k1 k2 k3 c (t :: k2 -> k3 -> k1) (t' :: k2 -> k3 -> k1) (a :: k2) (b :: k3). (Typeable t, Typeable t') => c (t a b) -> Maybe (c (t' a b))
mkFunTy :: TypeRep -> TypeRep -> TypeRep
rnfTypeRep :: TypeRep -> ()
showsTypeRep :: TypeRep -> ShowS
splitTyConApp :: TypeRep -> (TyCon, [TypeRep])
typeOf :: Typeable a => a -> TypeRep
typeOf1 :: Typeable t => t a -> TypeRep
typeOf2 :: Typeable t => t a b -> TypeRep
typeOf3 :: Typeable t => t a b c -> TypeRep
typeOf4 :: Typeable t => t a b c d -> TypeRep
typeOf5 :: Typeable t => t a b c d e -> TypeRep
typeOf6 :: Typeable t => t a b c d e f -> TypeRep
typeOf7 :: Typeable t => t a b c d e f g -> TypeRep
typeRep :: forall k proxy (a :: k). Typeable a => proxy a -> TypeRep
typeRepArgs :: TypeRep -> [TypeRep]
typeRepFingerprint :: TypeRep -> Fingerprint
typeRepTyCon :: TypeRep -> TyCon
rnfTyCon :: TyCon -> ()
tyConFingerprint :: TyCon -> Fingerprint
tyConModule :: TyCon -> String
tyConName :: TyCon -> String
tyConPackage :: TyCon -> String
data (a :: k) :~: (b :: k)
[Refl] :: forall k (a :: k). a :~: a
data (a :: k1) :~~: (b :: k2)
[HRefl] :: forall k1 (a :: k1). a :~~: a
type TypeRep = SomeTypeRep

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

-- | The type constructor used in definition of gmapQr
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

-- | Generic monadic transformations
type GenericM m ctx = forall a. Data ctx a => a -> m a

-- | The identity type constructor
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 :: * -> *)

-- | Generic map for transformations
gmapT :: Proxy ctx -> GenericT ctx -> GenericT ctx

-- | Generic map for monadic transformations
gmapM :: Monad m => Proxy ctx -> GenericM m ctx -> GenericM m ctx

-- | Map for queries
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

-- | Makes a constructor for primitive types
mkPrimCon :: DataType -> String -> ConstrRep -> Constr

-- | Makes a constructor for an Int
mkIntConstr :: DataType -> Integer -> Constr

-- | Makes a constructor for a Float
mkFloatConstr :: DataType -> Double -> Constr

-- | Makes a constructor for a String
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


-- | We can't warn about missing sigs as we have a group of decls in
--   quasi-quotes that we're going to put in a class instance
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]

-- | @<tt> instance Data NameSet where gunfold _ _ _ = error ("gunfold not
--   implemented") toConstr x = error ("toConstr not implemented for " ++
--   show (typeOf x)) dataTypeOf x = error ("dataTypeOf not implemented for
--   " ++ show (typeOf x)) gfoldl f z x = z x </tt>@
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]


-- | Instances of the Data class for Prelude-like types. We define
--   top-level definitions for representations.
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)
