@@ -1,8 +1,6 @@
11{-# LANGUAGE CPP #-}
2−{-# LANGUAGE GeneralizedNewtypeDeriving #-}
3−{-# LANGUAGE StandaloneDeriving #-}
4−{-# LANGUAGE TypeFamilies #-}
52{-# LANGUAGE TypeOperators #-}
3+{-# LANGUAGE TypeFamilies #-}
64-- |
75-- Module:
86-- Data.Patch
@@ -13,16 +11,11 @@ module Data.Patch
1311 , module X
1412 ) where
1513
16−import Control.Applicative
17−import Data.Functor.Const (Const (..))
18−import Data.Functor.Identity
19−import Data.Map.Monoidal (MonoidalMap)
20−import Data.Proxy
2114#if !MIN_VERSION_base(4,11,0)
2215import Data.Semigroup (Semigroup (..))
2316#endif
24−import GHC.Generics
2517
18+import Data.Semigroup.Additive as X
2619import Data.Patch.Class as X
2720import Data.Patch.DMap as X hiding (getDeletions)
2821import Data.Patch.DMapWithMove as X
@@ -39,68 +32,9 @@ import Data.Patch.MapWithMove as X
3932 , unsafePatchMapWithMove
4033 )
4134
42−-- | A 'Group' is a 'Monoid' where every element has an inverse.
43−class (Semigroup q, Monoid q) => Group q where
44− negateG :: q -> q
45− (~~) :: q -> q -> q
46− r ~~ s = r <> negateG s
47−
48−-- | An 'Additive' 'Semigroup' is one where (<>) is commutative
49−class Semigroup q => Additive q where
50−
5135-- | The elements of an 'Additive' 'Semigroup' can be considered as patches of their own type.
5236newtype AdditivePatch p = AdditivePatch { unAdditivePatch :: p }
5337
5438instance Additive p => Patch (AdditivePatch p) where
5539 type PatchTarget (AdditivePatch p) = p
5640 apply (AdditivePatch p) q = Just $ p <> q
57−
58−instance (Ord k, Group q) => Group (MonoidalMap k q) where
59− negateG = fmap negateG
60−
61−instance (Ord k, Additive q) => Additive (MonoidalMap k q)
62−
63−-- | Trivial group.
64−instance Group () where
65− negateG _ = ()
66− _ ~~ _ = ()
67−instance Additive ()
68−
69−-- | Product group. A Pair of groups gives rise to a group
70−instance (Group a, Group b) => Group (a, b) where
71− negateG (a, b) = (negateG a, negateG b)
72− (a, b) ~~ (c, d) = (a ~~ c, b ~~ d)
73−instance (Additive a, Additive b) => Additive (a, b)
74−
75−-- See https://gitlab.haskell.org/ghc/ghc/issues/11135#note_111802 for the reason Compose is not also provided.
76−-- Base does not define Monoid (Compose f g a) so this is the best we can
77−-- really do for functor composition.
78−instance Group (f (g a)) => Group ((f :.: g) a) where
79− negateG (Comp1 xs) = Comp1 (negateG xs)
80− Comp1 xs ~~ Comp1 ys = Comp1 (xs ~~ ys)
81−instance Additive (f (g a)) => Additive ((f :.: g) a)
82−
83−-- | Product of groups, Functor style.
84−instance (Group (f a), Group (g a)) => Group ((f :*: g) a) where
85− negateG (a :*: b) = negateG a :*: negateG b
86− (a :*: b) ~~ (c :*: d) = (a ~~ c) :*: (b ~~ d)
87−instance (Additive (f a), Additive (g a)) => Additive ((f :*: g) a)
88−
89−-- | Trivial group, Functor style
90−instance Group (Proxy x) where
91− negateG _ = Proxy
92− _ ~~ _ = Proxy
93−instance Additive (Proxy x)
94−
95−-- | Const lifts groups into a functor.
96−deriving instance Group a => Group (Const a x)
97−instance Additive a => Additive (Const a x)
98−-- | Ideitnty lifts groups pointwise (at only one point)
99−deriving instance Group a => Group (Identity a)
100−instance Additive a => Additive (Identity a)
101−
102−-- | Functions lift groups pointwise.
103−instance Group b => Group (a -> b) where
104− negateG f = negateG . f
105− (~~) = liftA2 (~~)
106−instance Additive b => Additive (a -> b)