packages feed

syb-with-class 0.6.1.6 → 0.6.1.7

raw patch · 2 files changed

+12/−7 lines, 2 filesdep ~template-haskellnew-uploaderPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: template-haskell

API changes (from Hackage documentation)

- Data.Generics.SYB.WithClass.Basics: confields :: Constr -> [String]
- Data.Generics.SYB.WithClass.Basics: confixity :: Constr -> Fixity
- Data.Generics.SYB.WithClass.Basics: conrep :: Constr -> ConstrRep
- Data.Generics.SYB.WithClass.Basics: constring :: Constr -> String
- Data.Generics.SYB.WithClass.Basics: datarep :: DataType -> DataRep
- Data.Generics.SYB.WithClass.Basics: datatype :: Constr -> DataType
- Data.Generics.SYB.WithClass.Basics: instance [overlap ok] Eq Constr
- Data.Generics.SYB.WithClass.Basics: instance [overlap ok] Eq ConstrRep
- Data.Generics.SYB.WithClass.Basics: instance [overlap ok] Eq DataRep
- Data.Generics.SYB.WithClass.Basics: instance [overlap ok] Eq Fixity
- Data.Generics.SYB.WithClass.Basics: instance [overlap ok] Show Constr
- Data.Generics.SYB.WithClass.Basics: instance [overlap ok] Show ConstrRep
- Data.Generics.SYB.WithClass.Basics: instance [overlap ok] Show DataRep
- Data.Generics.SYB.WithClass.Basics: instance [overlap ok] Show DataType
- Data.Generics.SYB.WithClass.Basics: instance [overlap ok] Show Fixity
- Data.Generics.SYB.WithClass.Basics: tycon :: DataType -> String
- Data.Generics.SYB.WithClass.Basics: unID :: ID x -> x
- Data.Generics.SYB.WithClass.Basics: unQr :: Qr r a -> r -> r
- Data.Generics.SYB.WithClass.Context: instance [overlap ok] (Sat (l a), Sat (r a)) => Sat (PairCtx l r a)
- Data.Generics.SYB.WithClass.Context: instance [overlap ok] Sat (NoCtx a)
- Data.Generics.SYB.WithClass.Context: leftCtx :: PairCtx l r a -> l a
- Data.Generics.SYB.WithClass.Context: rightCtx :: PairCtx l r a -> r a
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Data ctx (ForeignPtr Word8), Data ctx Int, Sat (ctx ByteString), Sat (ctx (ForeignPtr Word8)), Sat (ctx Int)) => Data ctx ByteString
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Data ctx ByteString, Sat (ctx ByteString), Sat (ctx ByteString)) => Data ctx ByteString
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (Either a b)), Data ctx a, Data ctx b) => Data ctx (Either a b)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (ForeignPtr a)), Typeable a) => Data ctx (ForeignPtr a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (IO a)), Typeable a) => Data ctx (IO a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (IORef a)), Typeable a) => Data ctx (IORef a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (MVar a)), Typeable a) => Data ctx (MVar a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (Map a b)), Data ctx a, Data ctx b, Ord a) => Data ctx (Map a b)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (Maybe a)), Data ctx a) => Data ctx (Maybe a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (Ptr a)), Typeable a) => Data ctx (Ptr a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (Ratio a)), Data ctx a, Integral a) => Data ctx (Ratio a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (ST s a)), Typeable s, Typeable a) => Data ctx (ST s a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (Set a)), Data ctx a, Ord a) => Data ctx (Set a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (StablePtr a)), Typeable a) => Data ctx (StablePtr a)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (a -> b)), Data ctx a, Data ctx b) => Data ctx (a -> b)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (a, b)), Data ctx a, Data ctx b) => Data ctx (a, b)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (a, b, c)), Data ctx a, Data ctx b, Data ctx c) => Data ctx (a, b, c)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (a, b, c, d)), Data ctx a, Data ctx b, Data ctx c, Data ctx d) => Data ctx (a, b, c, d)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (a, b, c, d, e)), Data ctx a, Data ctx b, Data ctx c, Data ctx d, Data ctx e) => Data ctx (a, b, c, d, e)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (a, b, c, d, e, f)), Data ctx a, Data ctx b, Data ctx c, Data ctx d, Data ctx e, Data ctx f) => Data ctx (a, b, c, d, e, f)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx (a, b, c, d, e, f, g)), Data ctx a, Data ctx b, Data ctx c, Data ctx d, Data ctx e, Data ctx f, Data ctx g) => Data ctx (a, b, c, d, e, f, g)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx [a]), Data ctx a) => Data ctx [a]
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] (Sat (ctx [b]), Sat (ctx (Array a b)), Typeable a, Data ctx b, Data ctx [b], Ix a) => Data ctx (Array a b)
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx ()) => Data ctx ()
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Bool) => Data ctx Bool
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Char) => Data ctx Char
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx DataType) => Data ctx DataType
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Double) => Data ctx Double
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Float) => Data ctx Float
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Handle) => Data ctx Handle
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Int) => Data ctx Int
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Int16) => Data ctx Int16
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Int32) => Data ctx Int32
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Int64) => Data ctx Int64
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Int8) => Data ctx Int8
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Integer) => Data ctx Integer
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Ordering) => Data ctx Ordering
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx TyCon) => Data ctx TyCon
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx TypeRep) => Data ctx TypeRep
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Word) => Data ctx Word
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Word16) => Data ctx Word16
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Word32) => Data ctx Word32
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Word64) => Data ctx Word64
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Sat (ctx Word8) => Data ctx Word8
- Data.Generics.SYB.WithClass.Instances: instance [overlap ok] Typeable DataType
+ Data.Generics.SYB.WithClass.Basics: [confields] :: Constr -> [String]
+ Data.Generics.SYB.WithClass.Basics: [confixity] :: Constr -> Fixity
+ Data.Generics.SYB.WithClass.Basics: [conrep] :: Constr -> ConstrRep
+ Data.Generics.SYB.WithClass.Basics: [constring] :: Constr -> String
+ Data.Generics.SYB.WithClass.Basics: [datarep] :: DataType -> DataRep
+ Data.Generics.SYB.WithClass.Basics: [datatype] :: Constr -> DataType
+ Data.Generics.SYB.WithClass.Basics: [tycon] :: DataType -> String
+ Data.Generics.SYB.WithClass.Basics: [unID] :: ID x -> x
+ Data.Generics.SYB.WithClass.Basics: [unQr] :: Qr r a -> r -> r
+ Data.Generics.SYB.WithClass.Basics: instance GHC.Classes.Eq Data.Generics.SYB.WithClass.Basics.Constr
+ Data.Generics.SYB.WithClass.Basics: instance GHC.Classes.Eq Data.Generics.SYB.WithClass.Basics.ConstrRep
+ Data.Generics.SYB.WithClass.Basics: instance GHC.Classes.Eq Data.Generics.SYB.WithClass.Basics.DataRep
+ Data.Generics.SYB.WithClass.Basics: instance GHC.Classes.Eq Data.Generics.SYB.WithClass.Basics.Fixity
+ Data.Generics.SYB.WithClass.Basics: instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.Constr
+ Data.Generics.SYB.WithClass.Basics: instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.ConstrRep
+ Data.Generics.SYB.WithClass.Basics: instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.DataRep
+ Data.Generics.SYB.WithClass.Basics: instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.DataType
+ Data.Generics.SYB.WithClass.Basics: instance GHC.Show.Show Data.Generics.SYB.WithClass.Basics.Fixity
+ Data.Generics.SYB.WithClass.Context: [leftCtx] :: PairCtx l r a -> l a
+ Data.Generics.SYB.WithClass.Context: [rightCtx] :: PairCtx l r a -> r a
+ Data.Generics.SYB.WithClass.Context: 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)
+ Data.Generics.SYB.WithClass.Context: instance Data.Generics.SYB.WithClass.Context.Sat (Data.Generics.SYB.WithClass.Context.NoCtx a)
+ Data.Generics.SYB.WithClass.Instances: 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
+ 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
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (Data.Map.Base.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.Base.Map a b)
+ Data.Generics.SYB.WithClass.Instances: instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (Data.Set.Base.Set a)), Data.Generics.SYB.WithClass.Basics.Data ctx a, GHC.Classes.Ord a) => Data.Generics.SYB.WithClass.Basics.Data ctx (Data.Set.Base.Set a)
+ Data.Generics.SYB.WithClass.Instances: instance (Data.Generics.SYB.WithClass.Context.Sat (ctx (GHC.Base.Maybe a)), Data.Generics.SYB.WithClass.Basics.Data ctx a) => Data.Generics.SYB.WithClass.Basics.Data ctx (GHC.Base.Maybe a)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: 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]
+ Data.Generics.SYB.WithClass.Instances: 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)
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx ()) => Data.Generics.SYB.WithClass.Basics.Data ctx ()
+ Data.Generics.SYB.WithClass.Instances: 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
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx Data.Typeable.Internal.TypeRep) => Data.Generics.SYB.WithClass.Basics.Data ctx Data.Typeable.Internal.TypeRep
+ Data.Generics.SYB.WithClass.Instances: 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
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Int.Int16) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Int.Int16
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Int.Int32) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Int.Int32
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Int.Int64) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Int.Int64
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Int.Int8) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Int.Int8
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Integer.Type.Integer) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Integer.Type.Integer
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Bool) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Bool
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Char) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Char
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Double) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Double
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Float) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Float
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Int) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Int
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Ordering) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Ordering
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.TyCon) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.TyCon
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Types.Word) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Types.Word
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Word.Word16) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Word.Word16
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Word.Word32) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Word.Word32
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Word.Word64) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Word.Word64
+ Data.Generics.SYB.WithClass.Instances: instance Data.Generics.SYB.WithClass.Context.Sat (ctx GHC.Word.Word8) => Data.Generics.SYB.WithClass.Basics.Data ctx GHC.Word.Word8

Files

Data/Generics/SYB/WithClass/Derive.hs view
@@ -244,8 +244,13 @@                [Constructor])   -- The constructors typeInfo d  = case d of+#if MIN_VERSION_template_haskell(2,11,0)+   DataD    _ n ps _ cs _ -> return (n, map varName ps, map conA cs)+   NewtypeD _ n ps _ c  _ -> return (n, map varName ps, [conA c])+#else    DataD    _ n ps cs _ -> return (n, map varName ps, map conA cs)    NewtypeD _ n ps c  _ -> return (n, map varName ps, [conA c])+#endif    _ -> error ("derive: not a data type declaration: " ++ show d)  where conA (NormalC c xs)   = (c, length xs, Nothing, map snd xs)        conA (InfixC x1 c x2) = conA (NormalC c [x1, x2])
syb-with-class.cabal view
@@ -1,5 +1,5 @@ Name:               syb-with-class-Version:            0.6.1.6+Version:            0.6.1.7 License:            BSD3 License-file:       LICENSE Copyright:          2004 - 2008 The University of Glasgow, CWI,@@ -14,18 +14,18 @@ Synopsis:           Scrap Your Boilerplate With Class Description:     Classes, and Template Haskell code to generate instances, for the-    Scrap Your Boilerplate With Class system.    +    Scrap Your Boilerplate With Class system. Category:           Data-Tested-With:        GHC==7.2.1+Tested-With:        GHC == 7.6.3, GHC == 7.8.4, GHC == 7.10.2, GHC==8.0.1 Build-Type:         Simple Cabal-Version:      >= 1.6  source-repository head-  type:     darcs-  location: http://patch-tag.com/r/Saizan/syb-with-class/+  type:     git+  location: https://github.com/Happstack/syb-with-class -Library -    Build-Depends:      base >= 3 && < 5, template-haskell >= 2.4 && < 2.11, bytestring, array, containers+Library+    Build-Depends:      base >= 3 && < 5, template-haskell >= 2.4 && < 2.12, bytestring, array, containers     Exposed-modules:         Data.Generics.SYB.WithClass.Basics         Data.Generics.SYB.WithClass.Context