patch 0.0.8.3 → 0.0.8.4

raw patch · 4 files changed

+10/−8 lines, 4 filesdep ~basenew-uploaderPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base

API changes (from Hackage documentation)

- Data.Functor.Misc: instance GHC.Base.Functor f => GHC.Base.Functor (Data.Functor.Misc.ComposeMaybe f)

- Data.Functor.Misc: instance forall k (f :: k -> *) (a :: k) (g :: k -> *) (g' :: k -> *). GHC.Show.Show (f a) => GHC.Show.Show (Data.Functor.Misc.WrapArg g f (g' a))

- Data.Functor.Misc: instance forall k (f :: k -> *) (a :: k) (g :: k -> *). GHC.Read.Read (f a) => GHC.Read.Read (Data.Functor.Misc.WrapArg g f (g a))

- Data.Functor.Misc: instance forall k (f :: k -> *) (a :: k). GHC.Show.Show (f a) => GHC.Show.Show (Data.Functor.Misc.ComposeMaybe f a)

- Data.Functor.Misc: instance forall k (l :: k) (r :: k) (a :: k). GHC.Show.Show (Data.Functor.Misc.EitherTag l r a)

- Data.Functor.Misc: instance forall k1 k2 (v :: k1). GHC.Show.Show k2 => Data.GADT.Internal.GShow (Data.Functor.Misc.Const2 k2 v)

- Data.Functor.Misc: instance forall x k (v :: x) (v' :: x). GHC.Show.Show k => GHC.Show.Show (Data.Functor.Misc.Const2 k v v')

- Data.Functor.Misc: instance forall x k (v :: x). GHC.Read.Read k => GHC.Read.Read (Data.Functor.Misc.Const2 k v v)

- Data.Monoid.DecidablyEmpty: instance (GHC.Classes.Ord a, GHC.Enum.Bounded a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Max a)

- Data.Monoid.DecidablyEmpty: instance (GHC.Classes.Ord a, GHC.Enum.Bounded a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Min a)

- Data.Monoid.DecidablyEmpty: instance (GHC.Num.Num a, GHC.Classes.Eq a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Internal.Product a)

- Data.Monoid.DecidablyEmpty: instance (GHC.Num.Num a, GHC.Classes.Eq a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Internal.Sum a)

- Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Monoid.First a)

- Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Monoid.Last a)

- Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty Data.Semigroup.Internal.All

- Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty Data.Semigroup.Internal.Any

- Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Functor.Identity.Identity a)

- Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Ord.Down a)

- Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Internal.Dual a)

- Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty p => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Generics.Par1 p)

- Data.Monoid.DecidablyEmpty: instance GHC.Base.Semigroup a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Maybe.Maybe a)

- Data.Monoid.DecidablyEmpty: instance forall k (f :: k -> *) (p :: k) (g :: k -> *). (Data.Monoid.DecidablyEmpty.DecidablyEmpty (f p), Data.Monoid.DecidablyEmpty.DecidablyEmpty (g p)) => Data.Monoid.DecidablyEmpty.DecidablyEmpty ((GHC.Generics.:*:) f g p)

- Data.Monoid.DecidablyEmpty: instance forall k (f :: k -> *) (p :: k) i (c :: GHC.Generics.Meta). Data.Monoid.DecidablyEmpty.DecidablyEmpty (f p) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Generics.M1 i c f p)

- Data.Monoid.DecidablyEmpty: instance forall k (f :: k -> *) (p :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty (f p) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Generics.Rec1 f p)

- Data.Monoid.DecidablyEmpty: instance forall k (p :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Generics.U1 p)

- Data.Monoid.DecidablyEmpty: instance forall k (s :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Proxy.Proxy s)

- Data.Monoid.DecidablyEmpty: instance forall k a (b :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Functor.Const.Const a b)

- Data.Monoid.DecidablyEmpty: instance forall k c i (p :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty c => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Generics.K1 i c p)

- Data.Monoid.DecidablyEmpty: instance forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1). Data.Monoid.DecidablyEmpty.DecidablyEmpty (f (g p)) => Data.Monoid.DecidablyEmpty.DecidablyEmpty ((GHC.Generics.:.:) f g p)

- Data.Patch: PatchMap :: Map k (Maybe v) -> PatchMap k v

- Data.Patch: [unPatchMap] :: PatchMap k v -> Map k (Maybe v)

- Data.Patch: apply :: Patch p => p -> PatchTarget p -> Maybe (PatchTarget p)

- Data.Patch: applyAlways :: Patch p => p -> PatchTarget p -> PatchTarget p

- Data.Patch: class Patch p where {

- Data.Patch: composePatchFunctions :: (Patch p, Semigroup p) => (PatchTarget p -> p) -> (PatchTarget p -> p) -> PatchTarget p -> p

- Data.Patch: instance Data.Patch.Group a => Data.Patch.Group (Data.Functor.Identity.Identity a)

- Data.Patch: instance forall k (f :: k -> *) (a :: k) (g :: k -> *). (Data.Patch.Group (f a), Data.Patch.Group (g a)) => Data.Patch.Group ((GHC.Generics.:*:) f g a)

- Data.Patch: instance forall k (x :: k). Data.Patch.Group (Data.Proxy.Proxy x)

- Data.Patch: instance forall k a (x :: k). Data.Patch.Group a => Data.Patch.Group (Data.Functor.Const.Const a x)

- Data.Patch: instance forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (a :: k1). Data.Patch.Group (f (g a)) => Data.Patch.Group ((GHC.Generics.:.:) f g a)

- Data.Patch: newtype PatchMap k v

- Data.Patch: patchMapNewElements :: PatchMap k v -> [v]

- Data.Patch: patchMapNewElementsMap :: PatchMap k v -> Map k v

- Data.Patch: type PatchTarget p :: Type;

- Data.Patch: }

- Data.Patch.Class: instance (GHC.Num.Num a, GHC.Classes.Eq a) => Data.Patch.Class.Patch (Data.Semigroup.Internal.Product a)

- Data.Patch.Class: instance (GHC.Num.Num a, GHC.Classes.Eq a) => Data.Patch.Class.Patch (Data.Semigroup.Internal.Sum a)

- Data.Patch.Class: instance Data.Patch.Class.Patch (Data.Functor.Identity.Identity a)

- Data.Patch.Class: instance Data.Patch.Class.Patch (Data.Proxy.Proxy a)

- Data.Patch.DMap: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Base.Monoid (Data.Patch.DMap.PatchDMap k2 v)

- Data.Patch.DMap: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Base.Semigroup (Data.Patch.DMap.PatchDMap k2 v)

- Data.Patch.DMapWithMove: instance forall a (k :: a -> *) (v :: a -> *) (b :: a). (GHC.Read.Read (v b), GHC.Read.Read (k b)) => GHC.Read.Read (Data.Patch.DMapWithMove.From k v b)

- Data.Patch.DMapWithMove: instance forall a (k :: a -> *) (v :: a -> *) (b :: a). (GHC.Show.Show (v b), GHC.Show.Show (k b)) => GHC.Show.Show (Data.Patch.DMapWithMove.From k v b)

- Data.Patch.DMapWithMove: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *) (a :: k1). (GHC.Show.Show (v a), GHC.Show.Show (k2 a)) => GHC.Show.Show (Data.Patch.DMapWithMove.NodeInfo k2 v a)

- Data.Patch.DMapWithMove: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Base.Monoid (Data.Patch.DMapWithMove.PatchDMapWithMove k2 v)

- Data.Patch.DMapWithMove: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Base.Semigroup (Data.Patch.DMapWithMove.PatchDMapWithMove k2 v)

- Data.Patch.IntMap: instance Data.Foldable.Foldable Data.Patch.IntMap.PatchIntMap

- Data.Patch.IntMap: instance Data.Traversable.Traversable Data.Patch.IntMap.PatchIntMap

- Data.Patch.IntMap: instance GHC.Base.Functor Data.Patch.IntMap.PatchIntMap

- Data.Patch.IntMap: instance GHC.Base.Monoid (Data.Patch.IntMap.PatchIntMap a)

- Data.Patch.IntMap: instance GHC.Base.Semigroup (Data.Patch.IntMap.PatchIntMap v)

- Data.Patch.IntMap: instance GHC.Read.Read a => GHC.Read.Read (Data.Patch.IntMap.PatchIntMap a)

- Data.Patch.IntMap: instance GHC.Show.Show a => GHC.Show.Show (Data.Patch.IntMap.PatchIntMap a)

- Data.Patch.Map: instance (GHC.Classes.Ord k, GHC.Read.Read k, GHC.Read.Read v) => GHC.Read.Read (Data.Patch.Map.PatchMap k v)

- Data.Patch.Map: instance (GHC.Show.Show k, GHC.Show.Show v) => GHC.Show.Show (Data.Patch.Map.PatchMap k v)

- Data.Patch.Map: instance Data.Foldable.Foldable (Data.Patch.Map.PatchMap k)

- Data.Patch.Map: instance Data.Traversable.Traversable (Data.Patch.Map.PatchMap k)

- Data.Patch.Map: instance GHC.Base.Functor (Data.Patch.Map.PatchMap k)

- Data.Patch.Map: instance GHC.Classes.Ord k => GHC.Base.Monoid (Data.Patch.Map.PatchMap k v)

- Data.Patch.Map: instance GHC.Classes.Ord k => GHC.Base.Semigroup (Data.Patch.Map.PatchMap k v)

- Data.Patch.MapWithMove: instance (GHC.Classes.Ord k, GHC.Read.Read k, GHC.Read.Read v) => GHC.Read.Read (Data.Patch.MapWithMove.PatchMapWithMove k v)

- Data.Patch.MapWithMove: instance (GHC.Read.Read k, GHC.Read.Read p) => GHC.Read.Read (Data.Patch.MapWithMove.NodeInfo k p)

- Data.Patch.MapWithMove: instance (GHC.Show.Show k, GHC.Show.Show p) => GHC.Show.Show (Data.Patch.MapWithMove.NodeInfo k p)

- Data.Patch.MapWithMove: instance (GHC.Show.Show k, GHC.Show.Show v) => GHC.Show.Show (Data.Patch.MapWithMove.PatchMapWithMove k v)

- Data.Patch.MapWithMove: instance Data.Foldable.Foldable (Data.Patch.MapWithMove.NodeInfo k)

- Data.Patch.MapWithMove: instance Data.Foldable.Foldable (Data.Patch.MapWithMove.PatchMapWithMove k)

- Data.Patch.MapWithMove: instance Data.Traversable.Traversable (Data.Patch.MapWithMove.NodeInfo k)

- Data.Patch.MapWithMove: instance Data.Traversable.Traversable (Data.Patch.MapWithMove.PatchMapWithMove k)

- Data.Patch.MapWithMove: instance GHC.Base.Functor (Data.Patch.MapWithMove.NodeInfo k)

- Data.Patch.MapWithMove: instance GHC.Base.Functor (Data.Patch.MapWithMove.PatchMapWithMove k)

- Data.Patch.MapWithMove: instance GHC.Classes.Ord k => GHC.Base.Monoid (Data.Patch.MapWithMove.PatchMapWithMove k v)

- Data.Patch.MapWithMove: instance GHC.Classes.Ord k => GHC.Base.Semigroup (Data.Patch.MapWithMove.PatchMapWithMove k v)

- Data.Patch.MapWithPatchingMove: instance (GHC.Classes.Ord k, Data.Monoid.DecidablyEmpty.DecidablyEmpty p, Data.Patch.Class.Patch p) => GHC.Base.Monoid (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)

- Data.Patch.MapWithPatchingMove: instance (GHC.Classes.Ord k, Data.Monoid.DecidablyEmpty.DecidablyEmpty p, Data.Patch.Class.Patch p) => GHC.Base.Semigroup (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)

- Data.Patch.MapWithPatchingMove: instance (GHC.Classes.Ord k, GHC.Read.Read k, GHC.Read.Read p, GHC.Read.Read (Data.Patch.Class.PatchTarget p)) => GHC.Read.Read (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)

- Data.Patch.MapWithPatchingMove: instance (GHC.Read.Read k, GHC.Read.Read p, GHC.Read.Read (Data.Patch.Class.PatchTarget p)) => GHC.Read.Read (Data.Patch.MapWithPatchingMove.From k p)

- Data.Patch.MapWithPatchingMove: instance (GHC.Read.Read k, GHC.Read.Read p, GHC.Read.Read (Data.Patch.Class.PatchTarget p)) => GHC.Read.Read (Data.Patch.MapWithPatchingMove.NodeInfo k p)

- Data.Patch.MapWithPatchingMove: instance (GHC.Show.Show k, GHC.Show.Show p, GHC.Show.Show (Data.Patch.Class.PatchTarget p)) => GHC.Show.Show (Data.Patch.MapWithPatchingMove.From k p)

- Data.Patch.MapWithPatchingMove: instance (GHC.Show.Show k, GHC.Show.Show p, GHC.Show.Show (Data.Patch.Class.PatchTarget p)) => GHC.Show.Show (Data.Patch.MapWithPatchingMove.NodeInfo k p)

- Data.Patch.MapWithPatchingMove: instance (GHC.Show.Show k, GHC.Show.Show p, GHC.Show.Show (Data.Patch.Class.PatchTarget p)) => GHC.Show.Show (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)

- Data.Patch.PatchOrReplacement: instance (GHC.Base.Monoid p, Data.Patch.Class.Patch p) => GHC.Base.Monoid (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

- Data.Patch.PatchOrReplacement: instance (GHC.Base.Semigroup p, Data.Patch.Class.Patch p) => GHC.Base.Semigroup (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

- Data.Patch.PatchOrReplacement: instance (GHC.Read.Read p, GHC.Read.Read (Data.Patch.Class.PatchTarget p)) => GHC.Read.Read (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

- Data.Patch.PatchOrReplacement: instance (GHC.Show.Show p, GHC.Show.Show (Data.Patch.Class.PatchTarget p)) => GHC.Show.Show (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

- Data.Patch.PatchOrReplacement: instance GHC.Generics.Generic (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

+ Data.Functor.Misc: instance GHC.Internal.Base.Functor f => GHC.Internal.Base.Functor (Data.Functor.Misc.ComposeMaybe f)

+ Data.Functor.Misc: instance forall k (f :: k -> *) (a :: k) (g :: k -> *) (g' :: k -> *). GHC.Internal.Show.Show (f a) => GHC.Internal.Show.Show (Data.Functor.Misc.WrapArg g f (g' a))

+ Data.Functor.Misc: instance forall k (f :: k -> *) (a :: k) (g :: k -> *). GHC.Internal.Read.Read (f a) => GHC.Internal.Read.Read (Data.Functor.Misc.WrapArg g f (g a))

+ Data.Functor.Misc: instance forall k (f :: k -> *) (a :: k). GHC.Internal.Show.Show (f a) => GHC.Internal.Show.Show (Data.Functor.Misc.ComposeMaybe f a)

+ Data.Functor.Misc: instance forall k (l :: k) (r :: k) (a :: k). GHC.Internal.Show.Show (Data.Functor.Misc.EitherTag l r a)

+ Data.Functor.Misc: instance forall k1 k2 (v :: k1). GHC.Internal.Show.Show k2 => Data.GADT.Internal.GShow (Data.Functor.Misc.Const2 k2 v)

+ Data.Functor.Misc: instance forall x k (v :: x) (v' :: x). GHC.Internal.Show.Show k => GHC.Internal.Show.Show (Data.Functor.Misc.Const2 k v v')

+ Data.Functor.Misc: instance forall x k (v :: x). GHC.Internal.Read.Read k => GHC.Internal.Read.Read (Data.Functor.Misc.Const2 k v v)

+ Data.Monoid.DecidablyEmpty: ($dmisEmpty) :: (DecidablyEmpty a, Eq a) => a -> Bool

+ Data.Monoid.DecidablyEmpty: instance (GHC.Classes.Ord a, GHC.Internal.Enum.Bounded a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Max a)

+ Data.Monoid.DecidablyEmpty: instance (GHC.Classes.Ord a, GHC.Internal.Enum.Bounded a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Min a)

+ Data.Monoid.DecidablyEmpty: instance (GHC.Internal.Num.Num a, GHC.Classes.Eq a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Data.Semigroup.Internal.Product a)

+ Data.Monoid.DecidablyEmpty: instance (GHC.Internal.Num.Num a, GHC.Classes.Eq a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Data.Semigroup.Internal.Sum a)

+ Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Data.Monoid.First a)

+ Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Data.Monoid.Last a)

+ Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty GHC.Internal.Data.Semigroup.Internal.All

+ Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty GHC.Internal.Data.Semigroup.Internal.Any

+ Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Data.Functor.Identity.Identity a)

+ Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Data.Ord.Down a)

+ Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Data.Semigroup.Internal.Dual a)

+ Data.Monoid.DecidablyEmpty: instance Data.Monoid.DecidablyEmpty.DecidablyEmpty p => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Generics.Par1 p)

+ Data.Monoid.DecidablyEmpty: instance GHC.Internal.Base.Semigroup a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Maybe.Maybe a)

+ Data.Monoid.DecidablyEmpty: instance forall k (f :: k -> *) (p :: k) (g :: k -> *). (Data.Monoid.DecidablyEmpty.DecidablyEmpty (f p), Data.Monoid.DecidablyEmpty.DecidablyEmpty (g p)) => Data.Monoid.DecidablyEmpty.DecidablyEmpty ((GHC.Internal.Generics.:*:) f g p)

+ Data.Monoid.DecidablyEmpty: instance forall k (f :: k -> *) (p :: k) i (c :: GHC.Internal.Generics.Meta). Data.Monoid.DecidablyEmpty.DecidablyEmpty (f p) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Generics.M1 i c f p)

+ Data.Monoid.DecidablyEmpty: instance forall k (f :: k -> *) (p :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty (f p) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Generics.Rec1 f p)

+ Data.Monoid.DecidablyEmpty: instance forall k (p :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Generics.U1 p)

+ Data.Monoid.DecidablyEmpty: instance forall k (s :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Data.Proxy.Proxy s)

+ Data.Monoid.DecidablyEmpty: instance forall k a (b :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Data.Functor.Const.Const a b)

+ Data.Monoid.DecidablyEmpty: instance forall k c i (p :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty c => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Internal.Generics.K1 i c p)

+ Data.Monoid.DecidablyEmpty: instance forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (p :: k1). Data.Monoid.DecidablyEmpty.DecidablyEmpty (f (g p)) => Data.Monoid.DecidablyEmpty.DecidablyEmpty ((GHC.Internal.Generics.:.:) f g p)

+ Data.Patch: instance Data.Patch.Group a => Data.Patch.Group (GHC.Internal.Data.Functor.Identity.Identity a)

+ Data.Patch: instance forall k (f :: k -> *) (a :: k) (g :: k -> *). (Data.Patch.Group (f a), Data.Patch.Group (g a)) => Data.Patch.Group ((GHC.Internal.Generics.:*:) f g a)

+ Data.Patch: instance forall k (x :: k). Data.Patch.Group (GHC.Internal.Data.Proxy.Proxy x)

+ Data.Patch: instance forall k a (x :: k). Data.Patch.Group a => Data.Patch.Group (GHC.Internal.Data.Functor.Const.Const a x)

+ Data.Patch: instance forall k2 k1 (f :: k2 -> *) (g :: k1 -> k2) (a :: k1). Data.Patch.Group (f (g a)) => Data.Patch.Group ((GHC.Internal.Generics.:.:) f g a)

+ Data.Patch.Class: instance (GHC.Internal.Num.Num a, GHC.Classes.Eq a) => Data.Patch.Class.Patch (GHC.Internal.Data.Semigroup.Internal.Product a)

+ Data.Patch.Class: instance (GHC.Internal.Num.Num a, GHC.Classes.Eq a) => Data.Patch.Class.Patch (GHC.Internal.Data.Semigroup.Internal.Sum a)

+ Data.Patch.Class: instance Data.Patch.Class.Patch (GHC.Internal.Data.Functor.Identity.Identity a)

+ Data.Patch.Class: instance Data.Patch.Class.Patch (GHC.Internal.Data.Proxy.Proxy a)

+ Data.Patch.DMap: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Internal.Base.Monoid (Data.Patch.DMap.PatchDMap k2 v)

+ Data.Patch.DMap: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Internal.Base.Semigroup (Data.Patch.DMap.PatchDMap k2 v)

+ Data.Patch.DMapWithMove: instance forall a (k :: a -> *) (v :: a -> *) (b :: a). (GHC.Internal.Read.Read (v b), GHC.Internal.Read.Read (k b)) => GHC.Internal.Read.Read (Data.Patch.DMapWithMove.From k v b)

+ Data.Patch.DMapWithMove: instance forall a (k :: a -> *) (v :: a -> *) (b :: a). (GHC.Internal.Show.Show (v b), GHC.Internal.Show.Show (k b)) => GHC.Internal.Show.Show (Data.Patch.DMapWithMove.From k v b)

+ Data.Patch.DMapWithMove: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *) (a :: k1). (GHC.Internal.Show.Show (v a), GHC.Internal.Show.Show (k2 a)) => GHC.Internal.Show.Show (Data.Patch.DMapWithMove.NodeInfo k2 v a)

+ Data.Patch.DMapWithMove: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Internal.Base.Monoid (Data.Patch.DMapWithMove.PatchDMapWithMove k2 v)

+ Data.Patch.DMapWithMove: instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Internal.Base.Semigroup (Data.Patch.DMapWithMove.PatchDMapWithMove k2 v)

+ Data.Patch.IntMap: instance GHC.Internal.Base.Functor Data.Patch.IntMap.PatchIntMap

+ Data.Patch.IntMap: instance GHC.Internal.Base.Monoid (Data.Patch.IntMap.PatchIntMap a)

+ Data.Patch.IntMap: instance GHC.Internal.Base.Semigroup (Data.Patch.IntMap.PatchIntMap v)

+ Data.Patch.IntMap: instance GHC.Internal.Data.Foldable.Foldable Data.Patch.IntMap.PatchIntMap

+ Data.Patch.IntMap: instance GHC.Internal.Data.Traversable.Traversable Data.Patch.IntMap.PatchIntMap

+ Data.Patch.IntMap: instance GHC.Internal.Read.Read a => GHC.Internal.Read.Read (Data.Patch.IntMap.PatchIntMap a)

+ Data.Patch.IntMap: instance GHC.Internal.Show.Show a => GHC.Internal.Show.Show (Data.Patch.IntMap.PatchIntMap a)

+ Data.Patch.Map: instance (GHC.Classes.Ord k, GHC.Internal.Read.Read k, GHC.Internal.Read.Read v) => GHC.Internal.Read.Read (Data.Patch.Map.PatchMap k v)

+ Data.Patch.Map: instance (GHC.Internal.Show.Show k, GHC.Internal.Show.Show v) => GHC.Internal.Show.Show (Data.Patch.Map.PatchMap k v)

+ Data.Patch.Map: instance GHC.Classes.Ord k => GHC.Internal.Base.Monoid (Data.Patch.Map.PatchMap k v)

+ Data.Patch.Map: instance GHC.Classes.Ord k => GHC.Internal.Base.Semigroup (Data.Patch.Map.PatchMap k v)

+ Data.Patch.Map: instance GHC.Internal.Base.Functor (Data.Patch.Map.PatchMap k)

+ Data.Patch.Map: instance GHC.Internal.Data.Foldable.Foldable (Data.Patch.Map.PatchMap k)

+ Data.Patch.Map: instance GHC.Internal.Data.Traversable.Traversable (Data.Patch.Map.PatchMap k)

+ Data.Patch.MapWithMove: instance (GHC.Classes.Ord k, GHC.Internal.Read.Read k, GHC.Internal.Read.Read v) => GHC.Internal.Read.Read (Data.Patch.MapWithMove.PatchMapWithMove k v)

+ Data.Patch.MapWithMove: instance (GHC.Internal.Read.Read k, GHC.Internal.Read.Read p) => GHC.Internal.Read.Read (Data.Patch.MapWithMove.NodeInfo k p)

+ Data.Patch.MapWithMove: instance (GHC.Internal.Show.Show k, GHC.Internal.Show.Show p) => GHC.Internal.Show.Show (Data.Patch.MapWithMove.NodeInfo k p)

+ Data.Patch.MapWithMove: instance (GHC.Internal.Show.Show k, GHC.Internal.Show.Show v) => GHC.Internal.Show.Show (Data.Patch.MapWithMove.PatchMapWithMove k v)

+ Data.Patch.MapWithMove: instance GHC.Classes.Ord k => GHC.Internal.Base.Monoid (Data.Patch.MapWithMove.PatchMapWithMove k v)

+ Data.Patch.MapWithMove: instance GHC.Classes.Ord k => GHC.Internal.Base.Semigroup (Data.Patch.MapWithMove.PatchMapWithMove k v)

+ Data.Patch.MapWithMove: instance GHC.Internal.Base.Functor (Data.Patch.MapWithMove.NodeInfo k)

+ Data.Patch.MapWithMove: instance GHC.Internal.Base.Functor (Data.Patch.MapWithMove.PatchMapWithMove k)

+ Data.Patch.MapWithMove: instance GHC.Internal.Data.Foldable.Foldable (Data.Patch.MapWithMove.NodeInfo k)

+ Data.Patch.MapWithMove: instance GHC.Internal.Data.Foldable.Foldable (Data.Patch.MapWithMove.PatchMapWithMove k)

+ Data.Patch.MapWithMove: instance GHC.Internal.Data.Traversable.Traversable (Data.Patch.MapWithMove.NodeInfo k)

+ Data.Patch.MapWithMove: instance GHC.Internal.Data.Traversable.Traversable (Data.Patch.MapWithMove.PatchMapWithMove k)

+ Data.Patch.MapWithPatchingMove: instance (GHC.Classes.Ord k, Data.Monoid.DecidablyEmpty.DecidablyEmpty p, Data.Patch.Class.Patch p) => GHC.Internal.Base.Monoid (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)

+ Data.Patch.MapWithPatchingMove: instance (GHC.Classes.Ord k, Data.Monoid.DecidablyEmpty.DecidablyEmpty p, Data.Patch.Class.Patch p) => GHC.Internal.Base.Semigroup (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)

+ Data.Patch.MapWithPatchingMove: instance (GHC.Classes.Ord k, GHC.Internal.Read.Read k, GHC.Internal.Read.Read p, GHC.Internal.Read.Read (Data.Patch.Class.PatchTarget p)) => GHC.Internal.Read.Read (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)

+ Data.Patch.MapWithPatchingMove: instance (GHC.Internal.Read.Read k, GHC.Internal.Read.Read p, GHC.Internal.Read.Read (Data.Patch.Class.PatchTarget p)) => GHC.Internal.Read.Read (Data.Patch.MapWithPatchingMove.From k p)

+ Data.Patch.MapWithPatchingMove: instance (GHC.Internal.Show.Show k, GHC.Internal.Show.Show p, GHC.Internal.Show.Show (Data.Patch.Class.PatchTarget p)) => GHC.Internal.Show.Show (Data.Patch.MapWithPatchingMove.From k p)

+ Data.Patch.PatchOrReplacement: instance (GHC.Internal.Base.Monoid p, Data.Patch.Class.Patch p) => GHC.Internal.Base.Monoid (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

+ Data.Patch.PatchOrReplacement: instance (GHC.Internal.Base.Semigroup p, Data.Patch.Class.Patch p) => GHC.Internal.Base.Semigroup (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

+ Data.Patch.PatchOrReplacement: instance (GHC.Internal.Read.Read p, GHC.Internal.Read.Read (Data.Patch.Class.PatchTarget p)) => GHC.Internal.Read.Read (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

+ Data.Patch.PatchOrReplacement: instance (GHC.Internal.Show.Show p, GHC.Internal.Show.Show (Data.Patch.Class.PatchTarget p)) => GHC.Internal.Show.Show (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

+ Data.Patch.PatchOrReplacement: instance GHC.Internal.Generics.Generic (Data.Patch.PatchOrReplacement.PatchOrReplacement p)

- Data.Functor.Misc: ComposeMaybe :: Maybe (f a) -> ComposeMaybe f a

+ Data.Functor.Misc: ComposeMaybe :: Maybe (f a) -> ComposeMaybe (f :: k -> Type) (a :: k)

- Data.Functor.Misc: [Const2] :: k -> Const2 k v v

+ Data.Functor.Misc: [Const2] :: forall {x} a (b :: x). a -> Const2 a b b

- Data.Functor.Misc: [LeftTag] :: EitherTag l r l

+ Data.Functor.Misc: [LeftTag] :: forall {k} (l :: k) (r :: k). EitherTag l r l

- Data.Functor.Misc: [RightTag] :: EitherTag l r r

+ Data.Functor.Misc: [RightTag] :: forall {k} (l :: k) (r :: k). EitherTag l r r

- Data.Functor.Misc: [WrapArg] :: f a -> WrapArg g f (g a)

+ Data.Functor.Misc: [WrapArg] :: forall {k} (b :: k -> Type) (a1 :: k) (a :: k -> Type). b a1 -> WrapArg a b (a a1)

- Data.Functor.Misc: [getComposeMaybe] :: ComposeMaybe f a -> Maybe (f a)

+ Data.Functor.Misc: [getComposeMaybe] :: ComposeMaybe (f :: k -> Type) (a :: k) -> Maybe (f a)

- Data.Functor.Misc: combineDMapsWithKey :: forall f g h i. GCompare f => (forall a. f a -> These (g a) (h a) -> i a) -> DMap f g -> DMap f h -> DMap f i

+ Data.Functor.Misc: combineDMapsWithKey :: GCompare f => (forall (a :: k). () => f a -> These (g a) (h a) -> i a) -> DMap f g -> DMap f h -> DMap f i

- Data.Functor.Misc: data Const2 :: Type -> x -> x -> Type

+ Data.Functor.Misc: data Const2 a (b :: x) (c :: x)

- Data.Functor.Misc: data EitherTag l r a

+ Data.Functor.Misc: data EitherTag (l :: k) (r :: k) (a :: k)

- Data.Functor.Misc: data WrapArg :: (k -> Type) -> (k -> Type) -> Type -> Type

+ Data.Functor.Misc: data WrapArg (a :: k -> Type) (b :: k -> Type) c

- Data.Functor.Misc: dmapToMapWith :: (f v -> v') -> DMap (Const2 k v) f -> Map k v'

+ Data.Functor.Misc: dmapToMapWith :: forall {k1} f (v :: k1) v' k2. (f v -> v') -> DMap (Const2 k2 v) f -> Map k2 v'

- Data.Functor.Misc: intMapWithFunctorToDMap :: IntMap (f v) -> DMap (Const2 Key v) f

+ Data.Functor.Misc: intMapWithFunctorToDMap :: forall {k} f (v :: k). IntMap (f v) -> DMap (Const2 Key v) f

- Data.Functor.Misc: mapKeyValuePairsMonotonic :: (DSum k v -> DSum k' v') -> DMap k v -> DMap k' v'

+ Data.Functor.Misc: mapKeyValuePairsMonotonic :: forall {k1} {k2} (k3 :: k1 -> Type) (v :: k1 -> Type) (k' :: k2 -> Type) (v' :: k2 -> Type). (DSum k3 v -> DSum k' v') -> DMap k3 v -> DMap k' v'

- Data.Functor.Misc: mapWithFunctorToDMap :: Map k (f v) -> DMap (Const2 k v) f

+ Data.Functor.Misc: mapWithFunctorToDMap :: forall {k1} k2 f (v :: k1). Map k2 (f v) -> DMap (Const2 k2 v) f

- Data.Functor.Misc: newtype ComposeMaybe f a

+ Data.Functor.Misc: newtype ComposeMaybe (f :: k -> Type) (a :: k)

- Data.Functor.Misc: unConst2 :: Const2 k v v' -> k

+ Data.Functor.Misc: unConst2 :: forall {x} k (v :: x) (v' :: x). Const2 k v v' -> k

- Data.Functor.Misc: weakenDMapWith :: (forall a. v a -> v') -> DMap k v -> Map (Some k) v'

+ Data.Functor.Misc: weakenDMapWith :: forall {k1} v v' (k2 :: k1 -> Type). (forall (a :: k1). () => v a -> v') -> DMap k2 v -> Map (Some k2) v'

- Data.Monoid.DecidablyEmpty: isEmpty :: (DecidablyEmpty a, Eq a) => a -> Bool

+ Data.Monoid.DecidablyEmpty: isEmpty :: DecidablyEmpty a => a -> Bool

- Data.Patch: PatchDMap :: DMap k (ComposeMaybe v) -> PatchDMap k v

+ Data.Patch: PatchDMap :: DMap k1 (ComposeMaybe v) -> PatchDMap (k1 :: k -> Type) (v :: k -> Type)

- Data.Patch: [unPatchDMap] :: PatchDMap k v -> DMap k (ComposeMaybe v)

+ Data.Patch: [unPatchDMap] :: PatchDMap (k1 :: k -> Type) (v :: k -> Type) -> DMap k1 (ComposeMaybe v)

- Data.Patch: const2IntPatchDMapWith :: forall v f a. (v -> f a) -> PatchIntMap v -> PatchDMap (Const2 Key a) f

+ Data.Patch: const2IntPatchDMapWith :: forall {k} v f (a :: k). (v -> f a) -> PatchIntMap v -> PatchDMap (Const2 Key a) f

- Data.Patch: const2PatchDMapWith :: forall k v v' a. (v -> v' a) -> PatchMap k v -> PatchDMap (Const2 k a) v'

+ Data.Patch: const2PatchDMapWith :: forall {k1} k2 v v' (a :: k1). (v -> v' a) -> PatchMap k2 v -> PatchDMap (Const2 k2 a) v'

- Data.Patch: const2PatchDMapWithMoveWith :: forall k v v' a. (v -> v' a) -> PatchMapWithMove k v -> PatchDMapWithMove (Const2 k a) v'

+ Data.Patch: const2PatchDMapWithMoveWith :: forall {k1} k2 v v' (a :: k1). (v -> v' a) -> PatchMapWithMove k2 v -> PatchDMapWithMove (Const2 k2 a) v'

- Data.Patch: data PatchDMapWithMove k v

+ Data.Patch: data PatchDMapWithMove (k1 :: k -> Type) (v :: k -> Type)

- Data.Patch: data PatchMapWithMove k (v :: Type)

+ Data.Patch: data PatchMapWithMove k v

- Data.Patch: mapPatchDMap :: (forall a. v a -> v' a) -> PatchDMap k v -> PatchDMap k v'

+ Data.Patch: mapPatchDMap :: forall {k1} v v' (k2 :: k1 -> Type). (forall (a :: k1). () => v a -> v' a) -> PatchDMap k2 v -> PatchDMap k2 v'

- Data.Patch: mapPatchDMapWithMove :: forall k v v'. (forall a. v a -> v' a) -> PatchDMapWithMove k v -> PatchDMapWithMove k v'

+ Data.Patch: mapPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) v v'. (forall (a :: k1). () => v a -> v' a) -> PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v'

- Data.Patch: newtype PatchDMap k v

+ Data.Patch: newtype PatchDMap (k1 :: k -> Type) (v :: k -> Type)

- Data.Patch: patchDMapToPatchMapWith :: (v a -> v') -> PatchDMap (Const2 k a) v -> PatchMap k v'

+ Data.Patch: patchDMapToPatchMapWith :: forall {k1} v (a :: k1) v' k2. (v a -> v') -> PatchDMap (Const2 k2 a) v -> PatchMap k2 v'

- Data.Patch: patchDMapWithMoveToPatchMapWithMoveWith :: forall k v v' a. (v a -> v') -> PatchDMapWithMove (Const2 k a) v -> PatchMapWithMove k v'

+ Data.Patch: patchDMapWithMoveToPatchMapWithMoveWith :: forall {k1} k2 v v' (a :: k1). (v a -> v') -> PatchDMapWithMove (Const2 k2 a) v -> PatchMapWithMove k2 v'

- Data.Patch: traversePatchDMap :: Applicative f => (forall a. v a -> f (v' a)) -> PatchDMap k v -> f (PatchDMap k v')

+ Data.Patch: traversePatchDMap :: forall {k1} f v v' (k2 :: k1 -> Type). Applicative f => (forall (a :: k1). () => v a -> f (v' a)) -> PatchDMap k2 v -> f (PatchDMap k2 v')

- Data.Patch: traversePatchDMapWithKey :: Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMap k v -> m (PatchDMap k v')

+ Data.Patch: traversePatchDMapWithKey :: forall {k1} m k2 v v'. Applicative m => (forall (a :: k1). () => k2 a -> v a -> m (v' a)) -> PatchDMap k2 v -> m (PatchDMap k2 v')

- Data.Patch: traversePatchDMapWithMoveWithKey :: forall m k v v'. Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMapWithMove k v -> m (PatchDMapWithMove k v')

+ Data.Patch: traversePatchDMapWithMoveWithKey :: forall {k1} m k2 v v'. Applicative m => (forall (a :: k1). () => k2 a -> v a -> m (v' a)) -> PatchDMapWithMove k2 v -> m (PatchDMapWithMove k2 v')

- Data.Patch: unPatchDMapWithMove :: PatchDMapWithMove k v -> DMap k (NodeInfo k v)

+ Data.Patch: unPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). PatchDMapWithMove k2 v -> DMap k2 (NodeInfo k2 v)

- Data.Patch: unsafePatchDMapWithMove :: DMap k (NodeInfo k v) -> PatchDMapWithMove k v

+ Data.Patch: unsafePatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). DMap k2 (NodeInfo k2 v) -> PatchDMapWithMove k2 v

- Data.Patch: weakenPatchDMapWith :: (forall a. v a -> v') -> PatchDMap k v -> PatchMap (Some k) v'

+ Data.Patch: weakenPatchDMapWith :: forall {k1} v v' (k2 :: k1 -> Type). (forall (a :: k1). () => v a -> v') -> PatchDMap k2 v -> PatchMap (Some k2) v'

- Data.Patch: weakenPatchDMapWithMoveWith :: forall k v v'. (forall a. v a -> v') -> PatchDMapWithMove k v -> PatchMapWithMove (Some k) v'

+ Data.Patch: weakenPatchDMapWithMoveWith :: forall {k1} (k2 :: k1 -> Type) v v'. (forall (a :: k1). () => v a -> v') -> PatchDMapWithMove k2 v -> PatchMapWithMove (Some k2) v'

- Data.Patch.Class: type PatchTarget p :: Type;

+ Data.Patch.Class: type PatchTarget p;

- Data.Patch.DMap: PatchDMap :: DMap k (ComposeMaybe v) -> PatchDMap k v

+ Data.Patch.DMap: PatchDMap :: DMap k1 (ComposeMaybe v) -> PatchDMap (k1 :: k -> Type) (v :: k -> Type)

- Data.Patch.DMap: [unPatchDMap] :: PatchDMap k v -> DMap k (ComposeMaybe v)

+ Data.Patch.DMap: [unPatchDMap] :: PatchDMap (k1 :: k -> Type) (v :: k -> Type) -> DMap k1 (ComposeMaybe v)

- Data.Patch.DMap: const2IntPatchDMapWith :: forall v f a. (v -> f a) -> PatchIntMap v -> PatchDMap (Const2 Key a) f

+ Data.Patch.DMap: const2IntPatchDMapWith :: forall {k} v f (a :: k). (v -> f a) -> PatchIntMap v -> PatchDMap (Const2 Key a) f

- Data.Patch.DMap: const2PatchDMapWith :: forall k v v' a. (v -> v' a) -> PatchMap k v -> PatchDMap (Const2 k a) v'

+ Data.Patch.DMap: const2PatchDMapWith :: forall {k1} k2 v v' (a :: k1). (v -> v' a) -> PatchMap k2 v -> PatchDMap (Const2 k2 a) v'

- Data.Patch.DMap: getDeletions :: GCompare k => PatchDMap k v -> DMap k v' -> DMap k v'

+ Data.Patch.DMap: getDeletions :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type) (v' :: k1 -> Type). GCompare k2 => PatchDMap k2 v -> DMap k2 v' -> DMap k2 v'

- Data.Patch.DMap: mapPatchDMap :: (forall a. v a -> v' a) -> PatchDMap k v -> PatchDMap k v'

+ Data.Patch.DMap: mapPatchDMap :: forall {k1} v v' (k2 :: k1 -> Type). (forall (a :: k1). () => v a -> v' a) -> PatchDMap k2 v -> PatchDMap k2 v'

- Data.Patch.DMap: newtype PatchDMap k v

+ Data.Patch.DMap: newtype PatchDMap (k1 :: k -> Type) (v :: k -> Type)

- Data.Patch.DMap: patchDMapToPatchMapWith :: (v a -> v') -> PatchDMap (Const2 k a) v -> PatchMap k v'

+ Data.Patch.DMap: patchDMapToPatchMapWith :: forall {k1} v (a :: k1) v' k2. (v a -> v') -> PatchDMap (Const2 k2 a) v -> PatchMap k2 v'

- Data.Patch.DMap: traversePatchDMap :: Applicative f => (forall a. v a -> f (v' a)) -> PatchDMap k v -> f (PatchDMap k v')

+ Data.Patch.DMap: traversePatchDMap :: forall {k1} f v v' (k2 :: k1 -> Type). Applicative f => (forall (a :: k1). () => v a -> f (v' a)) -> PatchDMap k2 v -> f (PatchDMap k2 v')

- Data.Patch.DMap: traversePatchDMapWithKey :: Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMap k v -> m (PatchDMap k v')

+ Data.Patch.DMap: traversePatchDMapWithKey :: forall {k1} m k2 v v'. Applicative m => (forall (a :: k1). () => k2 a -> v a -> m (v' a)) -> PatchDMap k2 v -> m (PatchDMap k2 v')

- Data.Patch.DMap: weakenPatchDMapWith :: (forall a. v a -> v') -> PatchDMap k v -> PatchMap (Some k) v'

+ Data.Patch.DMap: weakenPatchDMapWith :: forall {k1} v v' (k2 :: k1 -> Type). (forall (a :: k1). () => v a -> v') -> PatchDMap k2 v -> PatchMap (Some k2) v'

- Data.Patch.DMapWithMove: Fixup_Delete :: Fixup k v a

+ Data.Patch.DMapWithMove: Fixup_Delete :: Fixup (k1 :: k -> Type) (v :: k -> Type) (a :: k)

- Data.Patch.DMapWithMove: Fixup_Update :: These (From k v a) (To k a) -> Fixup k v a

+ Data.Patch.DMapWithMove: Fixup_Update :: These (From k1 v a) (To k1 a) -> Fixup (k1 :: k -> Type) (v :: k -> Type) (a :: k)

- Data.Patch.DMapWithMove: NodeInfo :: !From k v a -> !To k a -> NodeInfo k v a

+ Data.Patch.DMapWithMove: NodeInfo :: !From k1 v a -> !To k1 a -> NodeInfo (k1 :: k -> Type) (v :: k -> Type) (a :: k)

- Data.Patch.DMapWithMove: Pair1 :: f a -> g a -> Pair1 f g a

+ Data.Patch.DMapWithMove: Pair1 :: f a -> g a -> Pair1 (f :: k -> Type) (g :: k -> Type) (a :: k)

- Data.Patch.DMapWithMove: PatchDMapWithMove :: DMap k (NodeInfo k v) -> PatchDMapWithMove k v

+ Data.Patch.DMapWithMove: PatchDMapWithMove :: DMap k1 (NodeInfo k1 v) -> PatchDMapWithMove (k1 :: k -> Type) (v :: k -> Type)

- Data.Patch.DMapWithMove: [From_Delete] :: From k v a

+ Data.Patch.DMapWithMove: [From_Delete] :: forall {a} (k :: a -> Type) (v :: a -> Type) (b :: a). From k v b

- Data.Patch.DMapWithMove: [From_Insert] :: v a -> From k v a

+ Data.Patch.DMapWithMove: [From_Insert] :: forall {a} (v :: a -> Type) (b :: a) (k :: a -> Type). v b -> From k v b

- Data.Patch.DMapWithMove: [From_Move] :: !k a -> From k v a

+ Data.Patch.DMapWithMove: [From_Move] :: forall {a} (k :: a -> Type) (b :: a) (v :: a -> Type). !k b -> From k v b

- Data.Patch.DMapWithMove: [_nodeInfo_from] :: NodeInfo k v a -> !From k v a

+ Data.Patch.DMapWithMove: [_nodeInfo_from] :: NodeInfo (k1 :: k -> Type) (v :: k -> Type) (a :: k) -> !From k1 v a

- Data.Patch.DMapWithMove: [_nodeInfo_to] :: NodeInfo k v a -> !To k a

+ Data.Patch.DMapWithMove: [_nodeInfo_to] :: NodeInfo (k1 :: k -> Type) (v :: k -> Type) (a :: k) -> !To k1 a

- Data.Patch.DMapWithMove: const2PatchDMapWithMoveWith :: forall k v v' a. (v -> v' a) -> PatchMapWithMove k v -> PatchDMapWithMove (Const2 k a) v'

+ Data.Patch.DMapWithMove: const2PatchDMapWithMoveWith :: forall {k1} k2 v v' (a :: k1). (v -> v' a) -> PatchMapWithMove k2 v -> PatchDMapWithMove (Const2 k2 a) v'

- Data.Patch.DMapWithMove: data Fixup k v a

+ Data.Patch.DMapWithMove: data Fixup (k1 :: k -> Type) (v :: k -> Type) (a :: k)

- Data.Patch.DMapWithMove: data From (k :: a -> Type) (v :: a -> Type) :: a -> Type

+ Data.Patch.DMapWithMove: data From (k :: a -> Type) (v :: a -> Type) (b :: a)

- Data.Patch.DMapWithMove: data NodeInfo k v a

+ Data.Patch.DMapWithMove: data NodeInfo (k1 :: k -> Type) (v :: k -> Type) (a :: k)

- Data.Patch.DMapWithMove: data Pair1 f g a

+ Data.Patch.DMapWithMove: data Pair1 (f :: k -> Type) (g :: k -> Type) (a :: k)

- Data.Patch.DMapWithMove: deleteDMapKey :: k a -> PatchDMapWithMove k v

+ Data.Patch.DMapWithMove: deleteDMapKey :: forall {k1} k2 (a :: k1) (v :: k1 -> Type). k2 a -> PatchDMapWithMove k2 v

- Data.Patch.DMapWithMove: getDeletionsAndMoves :: GCompare k => PatchDMapWithMove k v -> DMap k v' -> DMap k (Product v' (ComposeMaybe k))

+ Data.Patch.DMapWithMove: getDeletionsAndMoves :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type) (v' :: k1 -> Type). GCompare k2 => PatchDMapWithMove k2 v -> DMap k2 v' -> DMap k2 (Product v' (ComposeMaybe k2))

- Data.Patch.DMapWithMove: insertDMapKey :: k a -> v a -> PatchDMapWithMove k v

+ Data.Patch.DMapWithMove: insertDMapKey :: forall {k1} k2 (a :: k1) v. k2 a -> v a -> PatchDMapWithMove k2 v

- Data.Patch.DMapWithMove: mapPatchDMapWithMove :: forall k v v'. (forall a. v a -> v' a) -> PatchDMapWithMove k v -> PatchDMapWithMove k v'

+ Data.Patch.DMapWithMove: mapPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) v v'. (forall (a :: k1). () => v a -> v' a) -> PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v'

- Data.Patch.DMapWithMove: moveDMapKey :: GCompare k => k a -> k a -> PatchDMapWithMove k v

+ Data.Patch.DMapWithMove: moveDMapKey :: forall {k1} k2 (a :: k1) (v :: k1 -> Type). GCompare k2 => k2 a -> k2 a -> PatchDMapWithMove k2 v

- Data.Patch.DMapWithMove: newtype PatchDMapWithMove k v

+ Data.Patch.DMapWithMove: newtype PatchDMapWithMove (k1 :: k -> Type) (v :: k -> Type)

- Data.Patch.DMapWithMove: nodeInfoMapFrom :: (From k v a -> From k v' a) -> NodeInfo k v a -> NodeInfo k v' a

+ Data.Patch.DMapWithMove: nodeInfoMapFrom :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type) (a :: k1) (v' :: k1 -> Type). (From k2 v a -> From k2 v' a) -> NodeInfo k2 v a -> NodeInfo k2 v' a

- Data.Patch.DMapWithMove: nodeInfoMapFromM :: Functor f => (From k v a -> f (From k v' a)) -> NodeInfo k v a -> f (NodeInfo k v' a)

+ Data.Patch.DMapWithMove: nodeInfoMapFromM :: forall {k1} f (k2 :: k1 -> Type) (v :: k1 -> Type) (a :: k1) (v' :: k1 -> Type). Functor f => (From k2 v a -> f (From k2 v' a)) -> NodeInfo k2 v a -> f (NodeInfo k2 v' a)

- Data.Patch.DMapWithMove: patchDMapWithMove :: (GCompare k, GShow k) => DMap k (NodeInfo k v) -> Either [String] (PatchDMapWithMove k v)

+ Data.Patch.DMapWithMove: patchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). (GCompare k2, GShow k2) => DMap k2 (NodeInfo k2 v) -> Either [String] (PatchDMapWithMove k2 v)

- Data.Patch.DMapWithMove: patchDMapWithMoveToPatchMapWithMoveWith :: forall k v v' a. (v a -> v') -> PatchDMapWithMove (Const2 k a) v -> PatchMapWithMove k v'

+ Data.Patch.DMapWithMove: patchDMapWithMoveToPatchMapWithMoveWith :: forall {k1} k2 v v' (a :: k1). (v a -> v') -> PatchDMapWithMove (Const2 k2 a) v -> PatchMapWithMove k2 v'

- Data.Patch.DMapWithMove: swapDMapKey :: GCompare k => k a -> k a -> PatchDMapWithMove k v

+ Data.Patch.DMapWithMove: swapDMapKey :: forall {k1} k2 (a :: k1) (v :: k1 -> Type). GCompare k2 => k2 a -> k2 a -> PatchDMapWithMove k2 v

- Data.Patch.DMapWithMove: traversePatchDMapWithMove :: forall m k v v'. Applicative m => (forall a. v a -> m (v' a)) -> PatchDMapWithMove k v -> m (PatchDMapWithMove k v')

+ Data.Patch.DMapWithMove: traversePatchDMapWithMove :: forall {k1} m (k2 :: k1 -> Type) v v'. Applicative m => (forall (a :: k1). () => v a -> m (v' a)) -> PatchDMapWithMove k2 v -> m (PatchDMapWithMove k2 v')

- Data.Patch.DMapWithMove: traversePatchDMapWithMoveWithKey :: forall m k v v'. Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMapWithMove k v -> m (PatchDMapWithMove k v')

+ Data.Patch.DMapWithMove: traversePatchDMapWithMoveWithKey :: forall {k1} m k2 v v'. Applicative m => (forall (a :: k1). () => k2 a -> v a -> m (v' a)) -> PatchDMapWithMove k2 v -> m (PatchDMapWithMove k2 v')

- Data.Patch.DMapWithMove: type To = ComposeMaybe

+ Data.Patch.DMapWithMove: type To = ComposeMaybe :: k -> Type -> k -> Type

- Data.Patch.DMapWithMove: unPatchDMapWithMove :: PatchDMapWithMove k v -> DMap k (NodeInfo k v)

+ Data.Patch.DMapWithMove: unPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). PatchDMapWithMove k2 v -> DMap k2 (NodeInfo k2 v)

- Data.Patch.DMapWithMove: unsafePatchDMapWithMove :: DMap k (NodeInfo k v) -> PatchDMapWithMove k v

+ Data.Patch.DMapWithMove: unsafePatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). DMap k2 (NodeInfo k2 v) -> PatchDMapWithMove k2 v

- Data.Patch.DMapWithMove: validPatchDMapWithMove :: forall k v. (GCompare k, GShow k) => DMap k (NodeInfo k v) -> Bool

+ Data.Patch.DMapWithMove: validPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). (GCompare k2, GShow k2) => DMap k2 (NodeInfo k2 v) -> Bool

- Data.Patch.DMapWithMove: validationErrorsForPatchDMapWithMove :: forall k v. (GCompare k, GShow k) => DMap k (NodeInfo k v) -> [String]

+ Data.Patch.DMapWithMove: validationErrorsForPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). (GCompare k2, GShow k2) => DMap k2 (NodeInfo k2 v) -> [String]

- Data.Patch.DMapWithMove: weakenPatchDMapWithMoveWith :: forall k v v'. (forall a. v a -> v') -> PatchDMapWithMove k v -> PatchMapWithMove (Some k) v'

+ Data.Patch.DMapWithMove: weakenPatchDMapWithMoveWith :: forall {k1} (k2 :: k1 -> Type) v v'. (forall (a :: k1). () => v a -> v') -> PatchDMapWithMove k2 v -> PatchMapWithMove (Some k2) v'

- Data.Patch.MapWithMove: From' :: From k (Proxy v) -> From k (v :: Type)

+ Data.Patch.MapWithMove: From' :: From k (Proxy v) -> From k v

- Data.Patch.MapWithMove: NodeInfo' :: NodeInfo k (Proxy v) -> NodeInfo k (v :: Type)

+ Data.Patch.MapWithMove: NodeInfo' :: NodeInfo k (Proxy v) -> NodeInfo k v

- Data.Patch.MapWithMove: PatchMapWithMove' :: PatchMapWithPatchingMove k (Proxy v) -> PatchMapWithMove k (v :: Type)

+ Data.Patch.MapWithMove: PatchMapWithMove' :: PatchMapWithPatchingMove k (Proxy v) -> PatchMapWithMove k v

- Data.Patch.MapWithMove: [unFrom'] :: From k (v :: Type) -> From k (Proxy v)

+ Data.Patch.MapWithMove: [unFrom'] :: From k v -> From k (Proxy v)

- Data.Patch.MapWithMove: [unNodeInfo'] :: NodeInfo k (v :: Type) -> NodeInfo k (Proxy v)

+ Data.Patch.MapWithMove: [unNodeInfo'] :: NodeInfo k v -> NodeInfo k (Proxy v)

- Data.Patch.MapWithMove: [unPatchMapWithMove'] :: PatchMapWithMove k (v :: Type) -> PatchMapWithPatchingMove k (Proxy v)

+ Data.Patch.MapWithMove: [unPatchMapWithMove'] :: PatchMapWithMove k v -> PatchMapWithPatchingMove k (Proxy v)

- Data.Patch.MapWithMove: newtype From k (v :: Type)

+ Data.Patch.MapWithMove: newtype From k v

- Data.Patch.MapWithMove: newtype NodeInfo k (v :: Type)

+ Data.Patch.MapWithMove: newtype NodeInfo k v

- Data.Patch.MapWithMove: newtype PatchMapWithMove k (v :: Type)

+ Data.Patch.MapWithMove: newtype PatchMapWithMove k v

- Data.Patch.MapWithPatchingMove: moveMapKey :: (DecidablyEmpty p, Patch p) => Ord k => k -> k -> PatchMapWithPatchingMove k p

+ Data.Patch.MapWithPatchingMove: moveMapKey :: (DecidablyEmpty p, Patch p, Ord k) => k -> k -> PatchMapWithPatchingMove k p

- Data.Patch.MapWithPatchingMove: patchThatChangesAndSortsMapWith :: forall k p. (Ord k, Ord (PatchTarget p), Monoid p) => (PatchTarget p -> PatchTarget p -> Ordering) -> Map k (PatchTarget p) -> Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

+ Data.Patch.MapWithPatchingMove: patchThatChangesAndSortsMapWith :: (Ord k, Ord (PatchTarget p), Monoid p) => (PatchTarget p -> PatchTarget p -> Ordering) -> Map k (PatchTarget p) -> Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

- Data.Patch.MapWithPatchingMove: patchThatChangesMap :: forall k p. (Ord k, Ord (PatchTarget p), Monoid p) => Map k (PatchTarget p) -> Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

+ Data.Patch.MapWithPatchingMove: patchThatChangesMap :: (Ord k, Ord (PatchTarget p), Monoid p) => Map k (PatchTarget p) -> Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

- Data.Patch.MapWithPatchingMove: swapMapKey :: (DecidablyEmpty p, Patch p) => Ord k => k -> k -> PatchMapWithPatchingMove k p

+ Data.Patch.MapWithPatchingMove: swapMapKey :: (DecidablyEmpty p, Patch p, Ord k) => k -> k -> PatchMapWithPatchingMove k p

- Data.Patch.PatchOrReplacement: _PatchOrReplacement_Patch :: forall p_aHRn. Prism' (PatchOrReplacement p_aHRn) p_aHRn

+ Data.Patch.PatchOrReplacement: _PatchOrReplacement_Patch :: forall p1 p2 f. (Choice p2, Applicative f) => p2 p1 (f p1) -> p2 (PatchOrReplacement p1) (f (PatchOrReplacement p1))

- Data.Patch.PatchOrReplacement: _PatchOrReplacement_Replacement :: forall p_aHRn. Prism' (PatchOrReplacement p_aHRn) (PatchTarget p_aHRn)

+ Data.Patch.PatchOrReplacement: _PatchOrReplacement_Replacement :: forall p1 p2 f. (Choice p2, Applicative f) => p2 (PatchTarget p1) (f (PatchTarget p1)) -> p2 (PatchOrReplacement p1) (f (PatchOrReplacement p1))

Files

ChangeLog.md +4/−0
patch.cabal +5/−4
src/Data/Functor/Misc.hs +0/−3
src/Data/Patch.hs +1/−1

ChangeLog.md view

@@ -1,5 +1,9 @@ # Revision history for patch +## 0.0.8.4++* Support for GHC 9.12+ ## 0.0.8.3  * Add support for GHC 9.8 and 9.10

patch.cabal view

@@ -1,13 +1,13 @@ cabal-version:      >=1.10 name:               patch-version:            0.0.8.3+version:            0.0.8.4 license:            BSD3 license-file:       LICENSE maintainer:         maintainer@obsidian.systems author:             Ryan Trinkle stability:          Experimental tested-with:-    ghc ==8.4.4 || ==8.6.5 || ==8.8.4 || ==8.10.7 || ==9.0.1 || ==9.2.5 || ==9.4.5 || ==9.6.1 || ==9.8.2 || ==9.10.1+    ghc ==8.4.4 || ==8.6.5 || ==8.8.4 || ==8.10.7 || ==9.0.1 || ==9.2.5 || ==9.4.5 || ==9.6.1 || ==9.8.2 || ==9.10.1 || ==9.12.1     ghcjs ==8.6 || ==8.10  homepage:           https://obsidian.systems@@ -58,7 +58,7 @@     default-extensions: PolyKinds     ghc-options:        -Wall -fwarn-redundant-constraints -fwarn-tabs     build-depends:-        base >=4.9 && <=4.21,+        base >=4.9 && <=4.22,         constraints-extras >=0.3 && <0.5,         commutative-semigroups >=0.0 && <0.3,         containers >=0.6 && <0.8,@@ -108,7 +108,8 @@         base,         directory,         filepath,-        filemanip+        filemanip,+        patch      if impl(ghc >=9.6)         buildable: False

src/Data/Functor/Misc.hs view

@@ -55,7 +55,6 @@ import Data.Some (Some, mkSome) import Data.These import Data.Type.Equality ((:~:)(Refl))-import Data.Typeable hiding (Refl)  -------------------------------------------------------------------------------- -- Const2@@ -66,7 +65,6 @@ -- parameter data Const2 :: Type -> x -> x -> Type where   Const2 :: k -> Const2 k v v-  deriving (Typeable)  -- | Extract the value from a Const2 unConst2 :: Const2 k v v' -> k@@ -188,7 +186,6 @@ data EitherTag l r a where   LeftTag :: EitherTag l r l   RightTag :: EitherTag l r r-  deriving (Typeable)  deriving instance Show (EitherTag l r a) deriving instance Eq (EitherTag l r a)

src/Data/Patch.hs view

@@ -30,7 +30,7 @@  -- N.B. Intentionally reexporting `Additive`, the deprecated alias, as -- this is a reexport for backwards compatibility.-import qualified Data.Semigroup.Additive as X+import Data.Semigroup.Additive as X import Data.Patch.Class as X import Data.Patch.DMap as X hiding (getDeletions) import Data.Patch.DMapWithMove as X