Move Additive to its own module

Author: Ericson2314

ChangeLog.md

@@ -15,6 +15,9 @@
 * `Applicative` is still defined, because the `Abelian` from `groups` has too
   stringent a constraint.
 
+* `Additive` now lives in `Data.Semigroup.Additive`, but is still reexported
+  from `Data.Patch` for compatability.
+
 ## 0.0.3.2
 
 * Update version bounds

patch.cabal

@@ -49,6 +49,7 @@ library
                  , Data.Patch.Map
                  , Data.Patch.MapWithMove
                  , Data.Patch.MapWithPatchingMove
+                 , Data.Semigroup.Additive
 
   ghc-options: -Wall -fwarn-redundant-constraints -fwarn-tabs
 

src/Data/Patch.hs

@@ -11,14 +11,11 @@ module Data.Patch
   , module X
   ) where
 
-import Data.Functor.Const (Const (..))
-import Data.Functor.Identity
-import Data.Proxy
 #if !MIN_VERSION_base(4,11,0)
 import Data.Semigroup (Semigroup (..))
 #endif
-import GHC.Generics
 
+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
@@ -35,37 +32,9 @@ import Data.Patch.MapWithMove as X
   , unsafePatchMapWithMove
   )
 
--- | An 'Additive' 'Semigroup' is one where (<>) is commutative
-class Semigroup q => Additive q where
-
 -- | The elements of an 'Additive' 'Semigroup' can be considered as patches of their own type.
 newtype AdditivePatch p = AdditivePatch { unAdditivePatch :: p }
 
 instance Additive p => Patch (AdditivePatch p) where
   type PatchTarget (AdditivePatch p) = p
   apply (AdditivePatch p) q = Just $ p <> q
-
--- | Trivial group.
-instance Additive ()
-
--- | Product group.  A Pair of groups gives rise to a group
-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 Additive (f (g a)) => Additive ((f :.: g) a)
-
--- | Product of groups, Functor style.
-instance (Additive (f a), Additive (g a)) => Additive ((f :*: g) a)
-
--- | Trivial group, Functor style
-instance Additive (Proxy x)
-
--- | Const lifts groups into a functor.
-instance Additive a => Additive (Const a x)
--- | Ideitnty lifts groups pointwise (at only one point)
-instance Additive a => Additive (Identity a)
-
--- | Functions lift groups pointwise.
-instance Additive b => Additive (a -> b)

src/Data/Semigroup/Additive.hs

@@ -0,0 +1,48 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE TypeOperators #-}
+{-# LANGUAGE TypeFamilies #-}
+-- |
+-- Module:
+--   Data.Semigroup.Additive
+-- Description:
+--   This module defines a class for commutative semigroups, until it is moved
+--   to another library.
+module Data.Semigroup.Additive
+  ( Additive
+  ) where
+
+import Data.Functor.Const (Const (..))
+import Data.Functor.Identity
+import Data.Proxy
+#if !MIN_VERSION_base(4,11,0)
+import Data.Semigroup (Semigroup (..))
+#endif
+import GHC.Generics
+
+-- | An 'Additive' 'Semigroup' is one where (<>) is commutative
+class Semigroup q => Additive q where
+
+-- | Trivial group.
+instance Additive ()
+
+-- | Product group.  A Pair of groups gives rise to a group
+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 Additive (f (g a)) => Additive ((f :.: g) a)
+
+-- | Product of groups, Functor style.
+instance (Additive (f a), Additive (g a)) => Additive ((f :*: g) a)
+
+-- | Trivial group, Functor style
+instance Additive (Proxy x)
+
+-- | Const lifts groups into a functor.
+instance Additive a => Additive (Const a x)
+-- | Ideitnty lifts groups pointwise (at only one point)
+instance Additive a => Additive (Identity a)
+
+-- | Functions lift groups pointwise.
+instance Additive b => Additive (a -> b)