Use groups package for group, a breaking change

TODO group's abelian should have Semigroup superclass.

The MonoidalMap instance was deleted because it is not lawful. But it
might need to be added to reflex.

The version in the cabal file is bumped to remind whoever does the
future release that this is breaking change.

Closes #4.

ChangeLog.md

@@ -1,5 +1,20 @@
 # Revision history for patch
 
+## Unreleased
+
+* Remove the `split-these` flag.
+  We do not need it as we only use the `These` datatype which is provided in all versions.
+
+* Stop defining `Group`; `Group` from the `groups` package can be used instead.
+
+  Most of the instances are provided by `groups`, except the `Group
+  MonoidalMap` instance, which is not lawful.  `reflex` might provide it as an
+  orphan for backwards compat, temporarily, but it should eventually be removed
+  everywhere.
+
+* `Applicative` is still defined, because the `Abelian` from `groups` has too
+  stringent a constraint.
+
 ## 0.0.3.2
 
 * Update version bounds

patch.cabal

@@ -1,5 +1,5 @@
 Name: patch
-Version: 0.0.3.2
+Version: 0.1.0.0
 Synopsis: Data structures for describing changes to other data structures.
 Description:
   Data structures for describing changes to other data structures.
@@ -25,11 +25,6 @@ tested-with:
   GHC ==8.0.2 || ==8.2.2 || ==8.4.4 || ==8.6.5 || ==8.8.1
   GHCJS ==8.4
 
-flag split-these
-  description: Use split these/semialign packages
-  manual:      False
-  default:     True
-
 library
   hs-source-dirs: src
   default-language: Haskell2010
@@ -40,6 +35,7 @@ library
                , dependent-sum >= 0.6 && < 0.8
                , lens >= 4.7 && < 5
                , semigroupoids >= 4.0 && < 6
+               , these >= 0.4 && < 1.2
                , transformers >= 0.5.6.0 && < 0.6
                , witherable >= 0.3 && < 0.4
 
@@ -56,14 +52,6 @@ library
 
   ghc-options: -Wall -fwarn-redundant-constraints -fwarn-tabs
 
-  if flag(split-these)
-    build-depends: these >= 1 && <1.2
-                 , semialign >=1 && <1.2
-                 , monoidal-containers >= 0.6 && < 0.7
-  else
-    build-depends: these >= 0.4 && <0.9
-                 , monoidal-containers == 0.4.0.0
-
 test-suite hlint
   default-language: Haskell2010
   type: exitcode-stdio-1.0

src/Data/Patch.hs

@@ -1,8 +1,6 @@
 {-# LANGUAGE CPP #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE StandaloneDeriving #-}
-{-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE TypeFamilies #-}
 -- |
 -- Module:
 --   Data.Patch
@@ -13,10 +11,8 @@ module Data.Patch
   , module X
   ) where
 
-import Control.Applicative
 import Data.Functor.Const (Const (..))
 import Data.Functor.Identity
-import Data.Map.Monoidal (MonoidalMap)
 import Data.Proxy
 #if !MIN_VERSION_base(4,11,0)
 import Data.Semigroup (Semigroup (..))
@@ -39,12 +35,6 @@ import Data.Patch.MapWithMove as X
   , unsafePatchMapWithMove
   )
 
--- | A 'Group' is a 'Monoid' where every element has an inverse.
-class (Semigroup q, Monoid q) => Group q where
-  negateG :: q -> q
-  (~~) :: q -> q -> q
-  r ~~ s = r <> negateG s
-
 -- | An 'Additive' 'Semigroup' is one where (<>) is commutative
 class Semigroup q => Additive q where
 
@@ -55,52 +45,27 @@ instance Additive p => Patch (AdditivePatch p) where
   type PatchTarget (AdditivePatch p) = p
   apply (AdditivePatch p) q = Just $ p <> q
 
-instance (Ord k, Group q) => Group (MonoidalMap k q) where
-  negateG = fmap negateG
-
-instance (Ord k, Additive q) => Additive (MonoidalMap k q)
-
 -- | Trivial group.
-instance Group () where
-  negateG _ = ()
-  _ ~~ _ = ()
 instance Additive ()
 
 -- | Product group.  A Pair of groups gives rise to a group
-instance (Group a, Group b) => Group (a, b) where
-  negateG (a, b) = (negateG a, negateG b)
-  (a, b) ~~ (c, d) = (a ~~ c, b ~~ d)
 instance (Additive a, Additive b) => Additive (a, b)
 
 -- See https://gitlab.haskell.org/ghc/ghc/issues/11135#note_111802 for the reason Compose is not also provided.
 -- Base does not define Monoid (Compose f g a) so this is the best we can
 -- really do for functor composition.
-instance Group (f (g a)) => Group ((f :.: g) a) where
-  negateG (Comp1 xs) = Comp1 (negateG xs)
-  Comp1 xs ~~ Comp1 ys = Comp1 (xs ~~ ys)
 instance Additive (f (g a)) => Additive ((f :.: g) a)
 
 -- | Product of groups, Functor style.
-instance (Group (f a), Group (g a)) => Group ((f :*: g) a) where
-  negateG (a :*: b) = negateG a :*: negateG b
-  (a :*: b) ~~ (c :*: d) = (a ~~ c) :*: (b ~~ d)
 instance (Additive (f a), Additive (g a)) => Additive ((f :*: g) a)
 
 -- | Trivial group, Functor style
-instance Group (Proxy x) where
-  negateG _ = Proxy
-  _ ~~ _ = Proxy
 instance Additive (Proxy x)
 
 -- | Const lifts groups into a functor.
-deriving instance Group a => Group (Const a x)
 instance Additive a => Additive (Const a x)
 -- | Ideitnty lifts groups pointwise (at only one point)
-deriving instance Group a => Group (Identity a)
 instance Additive a => Additive (Identity a)
 
 -- | Functions lift groups pointwise.
-instance Group b => Group (a -> b) where
-  negateG f = negateG . f
-  (~~) = liftA2 (~~)
 instance Additive b => Additive (a -> b)