syb-with-class 0.6.1 → 0.6.1.1

raw patch · 1 files changed

+3/−3 lines, 1 filesdep ~template-haskellPVP: 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.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] 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.Basics: dataCast1 :: (Data ctx a, Typeable1 t) => Proxy ctx -> (forall b. (Data ctx b) => w (t b)) -> Maybe (w a)

+ Data.Generics.SYB.WithClass.Basics: dataCast1 :: (Data ctx a, Typeable1 t) => Proxy ctx -> (forall b. Data ctx b => w (t b)) -> Maybe (w a)

- Data.Generics.SYB.WithClass.Basics: dataTypeOf :: (Data ctx a) => Proxy ctx -> a -> DataType

+ Data.Generics.SYB.WithClass.Basics: dataTypeOf :: Data ctx a => Proxy ctx -> a -> DataType

- Data.Generics.SYB.WithClass.Basics: fromConstr :: (Data ctx a) => Proxy ctx -> Constr -> a

+ Data.Generics.SYB.WithClass.Basics: fromConstr :: Data ctx a => Proxy ctx -> Constr -> a

- Data.Generics.SYB.WithClass.Basics: fromConstrB :: (Data ctx a) => Proxy ctx -> (forall b. (Data ctx b) => b) -> Constr -> a

+ Data.Generics.SYB.WithClass.Basics: fromConstrB :: Data ctx a => Proxy ctx -> (forall b. Data ctx b => b) -> Constr -> a

- Data.Generics.SYB.WithClass.Basics: fromConstrM :: (Monad m, Data ctx a) => Proxy ctx -> (forall b. (Data ctx b) => m b) -> Constr -> m a

+ Data.Generics.SYB.WithClass.Basics: fromConstrM :: (Monad m, Data ctx a) => Proxy ctx -> (forall b. Data ctx b => m b) -> Constr -> m a

- Data.Generics.SYB.WithClass.Basics: 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

+ Data.Generics.SYB.WithClass.Basics: 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

- Data.Generics.SYB.WithClass.Basics: gmapM :: (Monad m) => Proxy ctx -> GenericM m ctx -> GenericM m ctx

+ Data.Generics.SYB.WithClass.Basics: gmapM :: Monad m => Proxy ctx -> GenericM m ctx -> GenericM m ctx

- Data.Generics.SYB.WithClass.Basics: gmapQr :: (Data ctx a) => Proxy ctx -> (r' -> r -> r) -> r -> GenericQ ctx r' -> a -> r

+ Data.Generics.SYB.WithClass.Basics: gmapQr :: Data ctx a => Proxy ctx -> (r' -> r -> r) -> r -> GenericQ ctx r' -> a -> r

- Data.Generics.SYB.WithClass.Basics: 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

+ Data.Generics.SYB.WithClass.Basics: 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

- Data.Generics.SYB.WithClass.Basics: toConstr :: (Data ctx a) => Proxy ctx -> a -> Constr

+ Data.Generics.SYB.WithClass.Basics: toConstr :: Data ctx a => Proxy ctx -> a -> Constr

- Data.Generics.SYB.WithClass.Basics: type GenericQ ctx r = forall a. (Data ctx a) => a -> r

+ Data.Generics.SYB.WithClass.Basics: type GenericQ ctx r = forall a. Data ctx a => a -> r

- Data.Generics.SYB.WithClass.Context: dict :: (Sat a) => a

+ Data.Generics.SYB.WithClass.Context: dict :: Sat a => a

Files

syb-with-class.cabal +3/−3

syb-with-class.cabal view

@@ -1,5 +1,5 @@ Name:               syb-with-class-Version:            0.6.1+Version:            0.6.1.1 License:            BSD3 License-file:       LICENSE Copyright:          2004 - 2008 The University of Glasgow, CWI,@@ -22,10 +22,10 @@  source-repository head   type:     darcs-  location: http://patch-tag.com/r/Saizan/syb-with-class/pullrepo+  location: http://patch-tag.com/r/Saizan/syb-with-class/  Library -    Build-Depends:      base >= 3 && < 5, template-haskell >= 2.4 && < 2.5, bytestring, array, containers+    Build-Depends:      base >= 3 && < 5, template-haskell >= 2.4 && < 2.6, bytestring, array, containers     Exposed-modules:         Data.Generics.SYB.WithClass.Basics         Data.Generics.SYB.WithClass.Context