-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Data structures for describing changes to other data structures.
--   
--   Data structures for describing changes to other data structures.
--   
--   In this library, a patch is something which can be applied, analogous
--   to a function, and which distinguishes returning the argument it was
--   provided from returning something else.
@package patch
@version 0.0.7.0


-- | This module provides types and functions with no particular theme, but
--   which are relevant to the use of <a>Functor</a>-based datastructures
--   like <a>DMap</a>.
module Data.Functor.Misc

-- | <tt><a>Const2</a> k v v</tt> stores a value of a given type <tt>k</tt>
--   and ensures that a particular type <tt>v</tt> is always given for the
--   last type parameter
data Const2 :: Type -> x -> x -> Type
[Const2] :: k -> Const2 k v v

-- | Extract the value from a Const2
unConst2 :: Const2 k v v' -> k

-- | Convert a <a>DMap</a> to a regular <a>Map</a>
dmapToMap :: DMap (Const2 k v) Identity -> Map k v

-- | Convert a <a>DMap</a> to an <a>IntMap</a>
dmapToIntMap :: DMap (Const2 Key v) Identity -> IntMap v

-- | Convert a <a>DMap</a> to a regular <a>Map</a>, applying the given
--   function to remove the wrapping <a>Functor</a>
dmapToMapWith :: (f v -> v') -> DMap (Const2 k v) f -> Map k v'

-- | Convert a regular <a>Map</a> to a <a>DMap</a>
mapToDMap :: Map k v -> DMap (Const2 k v) Identity

-- | Convert a <a>DMap</a> to a regular <a>Map</a> by forgetting the types
--   associated with the keys, using a function to remove the wrapping
--   <a>Functor</a>
weakenDMapWith :: (forall a. v a -> v') -> DMap k v -> Map (Some k) v'

-- | <a>WrapArg</a> can be used to tag a value in one functor with a type
--   representing another functor. This was primarily used with
--   dependent-map &lt; 0.2, in which the value type was not wrapped in a
--   separate functor.
data WrapArg :: (k -> Type) -> (k -> Type) -> Type -> Type
[WrapArg] :: f a -> WrapArg g f (g a)

-- | Convert a regular <a>Map</a>, where the values are already wrapped in
--   a functor, to a <a>DMap</a>
mapWithFunctorToDMap :: Map k (f v) -> DMap (Const2 k v) f

-- | Convert a regular <a>IntMap</a>, where the values are already wrapped
--   in a functor, to a <a>DMap</a>
intMapWithFunctorToDMap :: IntMap (f v) -> DMap (Const2 Key v) f

-- | Map over all key/value pairs in a <a>DMap</a>, potentially altering
--   the key as well as the value. The provided function MUST preserve the
--   ordering of the keys, or the resulting <a>DMap</a> will be malformed.
mapKeyValuePairsMonotonic :: (DSum k v -> DSum k' v') -> DMap k v -> DMap k' v'

-- | Union two <a>DMap</a>s of different types, yielding another type. Each
--   key that is present in either input map will be present in the output.
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

-- | Tag type for <a>Either</a> to use it as a <a>DSum</a>.
data EitherTag l r a
[LeftTag] :: EitherTag l r l
[RightTag] :: EitherTag l r r

-- | Extract the values of a <a>DMap</a> of <a>EitherTag</a>s.
dmapToThese :: DMap (EitherTag a b) Identity -> Maybe (These a b)

-- | Convert <a>Either</a> to a <a>DSum</a>. Inverse of
--   <a>dsumToEither</a>.
eitherToDSum :: Either a b -> DSum (EitherTag a b) Identity

-- | Convert <a>DSum</a> to <a>Either</a>. Inverse of <a>eitherToDSum</a>.
dsumToEither :: DSum (EitherTag a b) Identity -> Either a b

-- | We can't use <tt><a>Compose</a> <a>Maybe</a></tt> instead of
--   <tt><a>ComposeMaybe</a></tt>, because that would make the <tt>f</tt>
--   parameter have a nominal type role. We need <tt>f</tt> to be
--   representational so that we can use safe <tt><a>coerce</a></tt>.
newtype ComposeMaybe f a
ComposeMaybe :: Maybe (f a) -> ComposeMaybe f a
[getComposeMaybe] :: ComposeMaybe f a -> Maybe (f a)
instance forall k (f :: k -> *) (a :: k). GHC.Classes.Ord (f a) => GHC.Classes.Ord (Data.Functor.Misc.ComposeMaybe f a)
instance forall k (f :: k -> *) (a :: k). GHC.Classes.Eq (f a) => GHC.Classes.Eq (Data.Functor.Misc.ComposeMaybe f a)
instance forall k (f :: k -> *) (a :: k). GHC.Show.Show (f a) => GHC.Show.Show (Data.Functor.Misc.ComposeMaybe f a)
instance forall x k (v :: x) (v' :: x). GHC.Classes.Eq k => GHC.Classes.Eq (Data.Functor.Misc.Const2 k v v')
instance forall x k (v :: x) (v' :: x). GHC.Classes.Ord k => GHC.Classes.Ord (Data.Functor.Misc.Const2 k v v')
instance forall x k (v :: x) (v' :: x). GHC.Show.Show k => GHC.Show.Show (Data.Functor.Misc.Const2 k v v')
instance forall x k (v :: x). GHC.Read.Read k => GHC.Read.Read (Data.Functor.Misc.Const2 k v v)
instance forall k (f :: k -> *) (a :: k) (g :: k -> *) (g' :: k -> *). GHC.Classes.Eq (f a) => GHC.Classes.Eq (Data.Functor.Misc.WrapArg g f (g' a))
instance forall k (f :: k -> *) (a :: k) (g :: k -> *) (g' :: k -> *). GHC.Classes.Ord (f a) => GHC.Classes.Ord (Data.Functor.Misc.WrapArg g f (g' a))
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))
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))
instance forall k (l :: k) (r :: k) (a :: k). GHC.Show.Show (Data.Functor.Misc.EitherTag l r a)
instance forall k (l :: k) (r :: k) (a :: k). GHC.Classes.Eq (Data.Functor.Misc.EitherTag l r a)
instance forall k (l :: k) (r :: k) (a :: k). GHC.Classes.Ord (Data.Functor.Misc.EitherTag l r a)
instance GHC.Base.Functor f => GHC.Base.Functor (Data.Functor.Misc.ComposeMaybe f)
instance forall k (l :: k) (r :: k). Data.GADT.Internal.GEq (Data.Functor.Misc.EitherTag l r)
instance forall k (l :: k) (r :: k). Data.GADT.Internal.GCompare (Data.Functor.Misc.EitherTag l r)
instance forall k (l :: k) (r :: k). Data.GADT.Internal.GShow (Data.Functor.Misc.EitherTag l r)
instance forall k (f :: k -> *) (g :: k -> *). Data.GADT.Internal.GEq f => Data.GADT.Internal.GEq (Data.Functor.Misc.WrapArg g f)
instance forall k (f :: k -> *) (g :: k -> *). Data.GADT.Internal.GCompare f => Data.GADT.Internal.GCompare (Data.Functor.Misc.WrapArg g f)
instance forall k1 k2 (v :: k1). GHC.Show.Show k2 => Data.GADT.Internal.GShow (Data.Functor.Misc.Const2 k2 v)
instance forall k1 k2 (v :: k1). GHC.Classes.Eq k2 => Data.GADT.Internal.GEq (Data.Functor.Misc.Const2 k2 v)
instance forall k1 k2 (v :: k1). GHC.Classes.Ord k2 => Data.GADT.Internal.GCompare (Data.Functor.Misc.Const2 k2 v)


module Data.Monoid.DecidablyEmpty

-- | A <a>DecidablyEmpty</a> is one where it can be computed whether or not
--   an arbitrary value is <a>mempty</a>.
--   
--   By using this class rather than <a>Eq</a>, we avoid unnecessary
--   constraining the contents of <a>Functor</a>s. This makes it possible
--   to efficiently combine and/or nest patch maps with <a>Eq</a>-lacking
--   values (e.g. functions) at the leaves.
class Monoid a => DecidablyEmpty a
isEmpty :: DecidablyEmpty a => a -> Bool
isEmpty :: (DecidablyEmpty a, Eq a) => a -> Bool
instance (GHC.Num.Num a, Data.Monoid.DecidablyEmpty.DecidablyEmpty a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Internal.Product a)
instance (Data.Monoid.DecidablyEmpty.DecidablyEmpty a, GHC.Num.Num a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Internal.Sum a)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Internal.Dual a)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Functor.Identity.Identity a)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty m => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.WrappedMonoid m)
instance forall k a (b :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Functor.Const.Const a b)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Ord.Down a)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty p => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Generics.Par1 p)
instance forall k (f :: k -> *) (p :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty (f p) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Generics.Rec1 f p)
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)
instance forall k c i (p :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty c => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Generics.K1 i c p)
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)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty GHC.Types.Ordering
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty ()
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty Data.Semigroup.Internal.Any
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty Data.Semigroup.Internal.All
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty [a]
instance GHC.Base.Semigroup a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Maybe.Maybe a)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Monoid.First a)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Monoid.Last a)
instance GHC.Base.Semigroup a => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Option a)
instance (GHC.Classes.Ord a, GHC.Enum.Bounded a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Max a)
instance (GHC.Classes.Ord a, GHC.Enum.Bounded a) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Semigroup.Min a)
instance forall k (s :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Proxy.Proxy s)
instance forall k (p :: k). Data.Monoid.DecidablyEmpty.DecidablyEmpty (GHC.Generics.U1 p)
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)
instance (Data.Monoid.DecidablyEmpty.DecidablyEmpty a, Data.Monoid.DecidablyEmpty.DecidablyEmpty b) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (a, b)
instance (Data.Monoid.DecidablyEmpty.DecidablyEmpty a, Data.Monoid.DecidablyEmpty.DecidablyEmpty b, Data.Monoid.DecidablyEmpty.DecidablyEmpty c) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (a, b, c)
instance (Data.Monoid.DecidablyEmpty.DecidablyEmpty a, Data.Monoid.DecidablyEmpty.DecidablyEmpty b, Data.Monoid.DecidablyEmpty.DecidablyEmpty c, Data.Monoid.DecidablyEmpty.DecidablyEmpty d) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (a, b, c, d)
instance (Data.Monoid.DecidablyEmpty.DecidablyEmpty a, Data.Monoid.DecidablyEmpty.DecidablyEmpty b, Data.Monoid.DecidablyEmpty.DecidablyEmpty c, Data.Monoid.DecidablyEmpty.DecidablyEmpty d, Data.Monoid.DecidablyEmpty.DecidablyEmpty e) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (a, b, c, d, e)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty Data.IntSet.Internal.IntSet
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.IntMap.Internal.IntMap v)
instance GHC.Classes.Ord k => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Map.Internal.Map k v)
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Sequence.Internal.Seq v)
instance GHC.Classes.Ord k => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Set.Internal.Set k)
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Dependent.Map.Internal.DMap k2 v)


-- | This is a class for types which represent changes made to other types
module Data.Patch.Class

-- | A <a>Patch</a> type represents a kind of change made to a
--   datastructure.
--   
--   If an instance of <a>Patch</a> is also an instance of
--   <a>Semigroup</a>, it should obey the law that <tt>applyAlways (f
--   &lt;&gt; g) == applyAlways f . applyAlways g</tt>.
class Patch p where {
    type family PatchTarget p :: Type;
}

-- | Apply the patch <tt>p a</tt> to the value <tt>a</tt>. If no change is
--   needed, return <a>Nothing</a>.
apply :: Patch p => p -> PatchTarget p -> Maybe (PatchTarget p)

-- | Apply a <a>Patch</a>; if it does nothing, return the original value
applyAlways :: Patch p => p -> PatchTarget p -> PatchTarget p

-- | Like <a>(.)</a>, but composes functions that return patches rather
--   than functions that return new values. The Semigroup instance for
--   patches must apply patches right-to-left, like <a>(.)</a>.
composePatchFunctions :: (Patch p, Semigroup p) => (PatchTarget p -> p) -> (PatchTarget p -> p) -> PatchTarget p -> p
instance Data.Patch.Class.Patch (Data.Functor.Identity.Identity a)
instance Data.Patch.Class.Patch (Data.Proxy.Proxy a)


-- | Patches of this sort allow for insert/update or delete of
--   associations.
module Data.Patch.IntMap

-- | <a>Patch</a> for <a>IntMap</a> which represents insertion or deletion
--   of keys in the mapping. Internally represented by 'IntMap (Maybe a)',
--   where <tt>Just</tt> means insert/update and <tt>Nothing</tt> means
--   delete.
newtype PatchIntMap a
PatchIntMap :: IntMap (Maybe a) -> PatchIntMap a
[unPatchIntMap] :: PatchIntMap a -> IntMap (Maybe a)

-- | Map a function <tt>Int -&gt; a -&gt; b</tt> over all <tt>a</tt>s in
--   the given <tt><a>PatchIntMap</a> a</tt> (that is, all
--   inserts/updates), producing a <tt>PatchIntMap b</tt>.
mapIntMapPatchWithKey :: (Int -> a -> b) -> PatchIntMap a -> PatchIntMap b

-- | Map an effectful function <tt>Int -&gt; a -&gt; f b</tt> over all
--   <tt>a</tt>s in the given <tt><a>PatchIntMap</a> a</tt> (that is, all
--   inserts/updates), producing a <tt>f (PatchIntMap b)</tt>.
traverseIntMapPatchWithKey :: Applicative f => (Int -> a -> f b) -> PatchIntMap a -> f (PatchIntMap b)

-- | Extract all <tt>a</tt>s inserted/updated by the given
--   <tt><a>PatchIntMap</a> a</tt>.
patchIntMapNewElements :: PatchIntMap a -> [a]

-- | Convert the given <tt><a>PatchIntMap</a> a</tt> into an
--   <tt><a>IntMap</a> a</tt> with all the inserts/updates in the given
--   patch.
patchIntMapNewElementsMap :: PatchIntMap a -> IntMap a

-- | Subset the given <tt><a>IntMap</a> a</tt> to contain only the keys
--   that would be deleted by the given <tt><a>PatchIntMap</a> a</tt>.
getDeletions :: PatchIntMap v -> IntMap v' -> IntMap v'
instance (Data.Patch.IntMap.PatchIntMap a1 GHC.Types.~ t) => Control.Lens.Wrapped.Rewrapped (Data.Patch.IntMap.PatchIntMap a2) t
instance Control.Lens.Wrapped.Wrapped (Data.Patch.IntMap.PatchIntMap a)
instance Data.Patch.Class.Patch (Data.Patch.IntMap.PatchIntMap a)
instance WithIndex.FunctorWithIndex GHC.Types.Int Data.Patch.IntMap.PatchIntMap
instance WithIndex.FoldableWithIndex GHC.Types.Int Data.Patch.IntMap.PatchIntMap
instance WithIndex.TraversableWithIndex GHC.Types.Int Data.Patch.IntMap.PatchIntMap
instance Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Patch.IntMap.PatchIntMap a)
instance GHC.Base.Monoid (Data.Patch.IntMap.PatchIntMap a)
instance Data.Traversable.Traversable Data.Patch.IntMap.PatchIntMap
instance Data.Foldable.Foldable Data.Patch.IntMap.PatchIntMap
instance GHC.Base.Functor Data.Patch.IntMap.PatchIntMap
instance GHC.Classes.Ord a => GHC.Classes.Ord (Data.Patch.IntMap.PatchIntMap a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Patch.IntMap.PatchIntMap a)
instance GHC.Read.Read a => GHC.Read.Read (Data.Patch.IntMap.PatchIntMap a)
instance GHC.Show.Show a => GHC.Show.Show (Data.Patch.IntMap.PatchIntMap a)
instance GHC.Base.Semigroup (Data.Patch.IntMap.PatchIntMap v)


-- | Patches of this type consist only of insertions (including overwrites)
--   and deletions.
module Data.Patch.Map

-- | A set of changes to a <a>Map</a>. Any element may be inserted/updated
--   or deleted. Insertions are represented as values wrapped in
--   <a>Just</a>, while deletions are represented as <a>Nothing</a>s
newtype PatchMap k v
PatchMap :: Map k (Maybe v) -> PatchMap k v
[unPatchMap] :: PatchMap k v -> Map k (Maybe v)

-- | Returns all the new elements that will be added to the <a>Map</a>
patchMapNewElements :: PatchMap k v -> [v]

-- | Returns all the new elements that will be added to the <a>Map</a>
patchMapNewElementsMap :: PatchMap k v -> Map k v
instance (Data.Patch.Map.PatchMap k1 v1 GHC.Types.~ t) => Control.Lens.Wrapped.Rewrapped (Data.Patch.Map.PatchMap k2 v2) t
instance Control.Lens.Wrapped.Wrapped (Data.Patch.Map.PatchMap k v)
instance WithIndex.FunctorWithIndex k (Data.Patch.Map.PatchMap k)
instance WithIndex.FoldableWithIndex k (Data.Patch.Map.PatchMap k)
instance WithIndex.TraversableWithIndex k (Data.Patch.Map.PatchMap k)
instance GHC.Classes.Ord k => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Patch.Map.PatchMap k v)
instance Data.Traversable.Traversable (Data.Patch.Map.PatchMap k)
instance Data.Foldable.Foldable (Data.Patch.Map.PatchMap k)
instance (GHC.Classes.Ord k, GHC.Classes.Ord v) => GHC.Classes.Ord (Data.Patch.Map.PatchMap k v)
instance (GHC.Classes.Eq k, GHC.Classes.Eq v) => GHC.Classes.Eq (Data.Patch.Map.PatchMap k v)
instance (GHC.Classes.Ord k, GHC.Read.Read k, GHC.Read.Read v) => GHC.Read.Read (Data.Patch.Map.PatchMap k v)
instance (GHC.Show.Show k, GHC.Show.Show v) => GHC.Show.Show (Data.Patch.Map.PatchMap k v)
instance GHC.Base.Functor (Data.Patch.Map.PatchMap k)
instance GHC.Classes.Ord k => GHC.Base.Monoid (Data.Patch.Map.PatchMap k v)
instance GHC.Classes.Ord k => GHC.Base.Semigroup (Data.Patch.Map.PatchMap k v)
instance GHC.Classes.Ord k => Data.Patch.Class.Patch (Data.Patch.Map.PatchMap k v)


-- | Patches of this type consist only of insertions (including overwrites)
--   and deletions.
module Data.Patch.DMap

-- | A set of changes to a <a>DMap</a>. Any element may be inserted/updated
--   or deleted. Insertions are represented as <tt><a>ComposeMaybe</a>
--   (Just value)</tt>, while deletions are represented as
--   <tt><a>ComposeMaybe</a> Nothing</tt>.
newtype PatchDMap k v
PatchDMap :: DMap k (ComposeMaybe v) -> PatchDMap k v
[unPatchDMap] :: PatchDMap k v -> DMap k (ComposeMaybe v)

-- | Map a function <tt>v a -&gt; v' a</tt> over any inserts/updates in the
--   given <tt><a>PatchDMap</a> k v</tt> to produce a <tt><a>PatchDMap</a>
--   k v'</tt>.
mapPatchDMap :: (forall a. v a -> v' a) -> PatchDMap k v -> PatchDMap k v'

-- | Map an effectful function <tt>v a -&gt; f (v' a)</tt> over any
--   inserts/updates in the given <tt><a>PatchDMap</a> k v</tt> to produce
--   a <tt><a>PatchDMap</a> k v'</tt>.
traversePatchDMap :: Applicative f => (forall a. v a -> f (v' a)) -> PatchDMap k v -> f (PatchDMap k v')

-- | Map an effectful function <tt>k a -&gt; v a -&gt; f (v' a)</tt> over
--   any inserts/updates in the given <tt><a>PatchDMap</a> k v</tt> to
--   produce a <tt><a>PatchDMap</a> k v'</tt>.
traversePatchDMapWithKey :: Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMap k v -> m (PatchDMap k v')

-- | Weaken a <tt><a>PatchDMap</a> k v</tt> to a <tt><a>PatchMap</a> (Some
--   k) v'</tt> using a function <tt>v a -&gt; v'</tt> to weaken each value
--   contained in the patch.
weakenPatchDMapWith :: (forall a. v a -> v') -> PatchDMap k v -> PatchMap (Some k) v'

-- | Convert a weak <tt><a>PatchDMap</a> (<a>Const2</a> k a) v</tt> where
--   the <tt>a</tt> is known by way of the <tt>Const2</tt> into a
--   <tt><a>PatchMap</a> k v'</tt> using a rank 1 function <tt>v a -&gt;
--   v'</tt>.
patchDMapToPatchMapWith :: (v a -> v') -> PatchDMap (Const2 k a) v -> PatchMap k v'

-- | Convert a <tt><a>PatchMap</a> k v</tt> into a <tt><a>PatchDMap</a>
--   (<a>Const2</a> k a) v'</tt> using a function <tt>v -&gt; v' a</tt>.
const2PatchDMapWith :: forall k v v' a. (v -> v' a) -> PatchMap k v -> PatchDMap (Const2 k a) v'

-- | Convert a <tt><a>PatchIntMap</a> v</tt> into a <tt><a>PatchDMap</a>
--   (<a>Const2</a> Int a) v'</tt> using a function <tt>v -&gt; v' a</tt>.
const2IntPatchDMapWith :: forall v f a. (v -> f a) -> PatchIntMap v -> PatchDMap (Const2 Key a) f

-- | Get the values that will be replaced or deleted if the given patch is
--   applied to the given <a>DMap</a>.
getDeletions :: GCompare k => PatchDMap k v -> DMap k v' -> DMap k v'
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Base.Semigroup (Data.Patch.DMap.PatchDMap k2 v)
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Base.Monoid (Data.Patch.DMap.PatchDMap k2 v)
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Patch.DMap.PatchDMap k2 v)
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => Data.Patch.Class.Patch (Data.Patch.DMap.PatchDMap k2 v)


-- | Patches of this type can can insert, delete, and move values from one
--   key to another, and move patches may also additionally patch the value
--   being moved.
module Data.Patch.MapWithPatchingMove

-- | Patch a Map with additions, deletions, and moves. Invariant: If key
--   <tt>k1</tt> is coming from <tt>From_Move k2</tt>, then key <tt>k2</tt>
--   should be going to <tt>Just k1</tt>, and vice versa. There should
--   never be any unpaired From/To keys.
newtype PatchMapWithPatchingMove k p
PatchMapWithPatchingMove :: Map k (NodeInfo k p) -> PatchMapWithPatchingMove k p

-- | Extract the internal representation of the
--   <a>PatchMapWithPatchingMove</a>
[unPatchMapWithPatchingMove] :: PatchMapWithPatchingMove k p -> Map k (NodeInfo k p)

-- | Create a <a>PatchMapWithPatchingMove</a>, validating it
patchMapWithPatchingMove :: Ord k => Map k (NodeInfo k p) -> Maybe (PatchMapWithPatchingMove k p)

-- | Create a <a>PatchMapWithPatchingMove</a> that inserts everything in
--   the given <a>Map</a>
patchMapWithPatchingMoveInsertAll :: Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

-- | Make a <tt><a>PatchMapWithPatchingMove</a> k p</tt> which has the
--   effect of inserting or replacing a value <tt>v</tt> at the given key
--   <tt>k</tt>, like <a>insert</a>.
insertMapKey :: k -> PatchTarget p -> PatchMapWithPatchingMove k p

-- | Make a <tt><a>PatchMapWithPatchingMove</a> k p</tt> which has the
--   effect of moving the value from the first key <tt>k</tt> to the second
--   key <tt>k</tt>, equivalent to:
--   
--   <pre>
--   <a>delete</a> src (maybe map (<a>insert</a> dst) (Map.lookup src map))
--   </pre>
moveMapKey :: (DecidablyEmpty p, Patch p) => Ord k => k -> k -> PatchMapWithPatchingMove k p

-- | Make a <tt><a>PatchMapWithPatchingMove</a> k p</tt> which has the
--   effect of swapping two keys in the mapping, equivalent to:
--   
--   <pre>
--   let aMay = Map.lookup a map
--       bMay = Map.lookup b map
--   in maybe id (Map.insert a) (bMay &lt;&gt; aMay)
--    . maybe id (Map.insert b) (aMay &lt;&gt; bMay)
--    . Map.delete a . Map.delete b $ map
--   </pre>
swapMapKey :: (DecidablyEmpty p, Patch p) => Ord k => k -> k -> PatchMapWithPatchingMove k p

-- | Make a <tt><a>PatchMapWithPatchingMove</a> k v</tt> which has the
--   effect of deleting a key in the mapping, equivalent to <a>delete</a>.
deleteMapKey :: k -> PatchMapWithPatchingMove k v

-- | Wrap a <tt><a>Map</a> k (NodeInfo k v)</tt> representing patch changes
--   into a <tt><a>PatchMapWithPatchingMove</a> k v</tt>, without checking
--   any invariants.
--   
--   <b>Warning:</b> when using this function, you must ensure that the
--   invariants of <a>PatchMapWithPatchingMove</a> are preserved; they will
--   not be checked.
unsafePatchMapWithPatchingMove :: Map k (NodeInfo k p) -> PatchMapWithPatchingMove k p

-- | Returns all the new elements that will be added to the <a>Map</a>
patchMapWithPatchingMoveNewElements :: PatchMapWithPatchingMove k p -> [PatchTarget p]

-- | Return a <tt><a>Map</a> k v</tt> with all the inserts/updates from the
--   given <tt><a>PatchMapWithPatchingMove</a> k v</tt>.
patchMapWithPatchingMoveNewElementsMap :: PatchMapWithPatchingMove k p -> Map k (PatchTarget p)

-- | Create a <a>PatchMapWithPatchingMove</a> that, if applied to the given
--   <a>Map</a>, will sort its values using the given ordering function.
--   The set keys of the <a>Map</a> is not changed.
patchThatSortsMapWith :: (Ord k, Monoid p) => (PatchTarget p -> PatchTarget p -> Ordering) -> Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

-- | Create a <a>PatchMapWithPatchingMove</a> that, if applied to the first
--   <a>Map</a> provided, will produce a <a>Map</a> with the same values as
--   the second <a>Map</a> but with the values sorted with the given
--   ordering function.
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

-- | Create a <a>PatchMapWithPatchingMove</a> that, if applied to the first
--   <a>Map</a> provided, will produce the second <a>Map</a>. Note: this
--   will never produce a patch on a value.
patchThatChangesMap :: forall k p. (Ord k, Ord (PatchTarget p), Monoid p) => Map k (PatchTarget p) -> Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

-- | Holds the information about each key: where its new value should come
--   from, and where its old value should go to
data NodeInfo k p
NodeInfo :: !From k p -> !To k -> NodeInfo k p

-- | Where do we get the new value for this key?
[_nodeInfo_from] :: NodeInfo k p -> !From k p

-- | If the old value is being kept (i.e. moved rather than deleted or
--   replaced), where is it going?
[_nodeInfo_to] :: NodeInfo k p -> !To k

-- | Traverse the <a>NodeInfo</a> over the key, patch, and patch target.
--   Because of the type families here, this doesn't it any bi- or
--   tri-traversal class.
bitraverseNodeInfo :: Applicative f => (k0 -> f k1) -> (p0 -> f p1) -> (PatchTarget p0 -> f (PatchTarget p1)) -> NodeInfo k0 p0 -> f (NodeInfo k1 p1)

-- | Change the <a>From</a> value of a <a>NodeInfo</a>
nodeInfoMapFrom :: (From k v -> From k v) -> NodeInfo k v -> NodeInfo k v

-- | Change the <a>From</a> value of a <a>NodeInfo</a>, using a
--   <a>Functor</a> (or <a>Applicative</a>, <a>Monad</a>, etc.) action to
--   get the new value
nodeInfoMapMFrom :: Functor f => (From k v -> f (From k v)) -> NodeInfo k v -> f (NodeInfo k v)

-- | Set the <a>To</a> field of a <a>NodeInfo</a>
nodeInfoSetTo :: To k -> NodeInfo k v -> NodeInfo k v

-- | Describe how a key's new value should be produced
data From k p

-- | Insert the given value here
From_Insert :: PatchTarget p -> From k p

-- | Delete the existing value, if any, from here
From_Delete :: From k p

-- | Move the value here from the given key, and apply the given patch
From_Move :: !k -> !p -> From k p

-- | Traverse the <a>From</a> over the key, patch, and patch target.
--   Because of the type families here, this doesn't it any bi- or
--   tri-traversal class.
bitraverseFrom :: Applicative f => (k0 -> f k1) -> (p0 -> f p1) -> (PatchTarget p0 -> f (PatchTarget p1)) -> From k0 p0 -> f (From k1 p1)

-- | Describe where a key's old value will go. If this is <a>Just</a>, that
--   means the key's old value will be moved to the given other key; if it
--   is <a>Nothing</a>, that means it will be deleted.
type To = Maybe

-- | Helper data structure used for composing patches using the monoid
--   instance.
data Fixup k v
Fixup_Delete :: Fixup k v
Fixup_Update :: These (From k v) (To k) -> Fixup k v
instance (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k1 p1 GHC.Types.~ t) => Control.Lens.Wrapped.Rewrapped (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k2 p2) t
instance Control.Lens.Wrapped.Wrapped (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)
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)
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)
instance (GHC.Classes.Eq k, GHC.Classes.Eq p, GHC.Classes.Eq (Data.Patch.Class.PatchTarget p)) => GHC.Classes.Eq (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)
instance (GHC.Classes.Ord k, GHC.Classes.Ord p, GHC.Classes.Ord (Data.Patch.Class.PatchTarget p)) => GHC.Classes.Ord (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)
instance (GHC.Classes.Ord k, Data.Monoid.DecidablyEmpty.DecidablyEmpty p, Data.Patch.Class.Patch p) => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)
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)
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)
instance (GHC.Classes.Eq k, GHC.Classes.Eq p, GHC.Classes.Eq (Data.Patch.Class.PatchTarget p)) => GHC.Classes.Eq (Data.Patch.MapWithPatchingMove.NodeInfo k p)
instance (GHC.Classes.Ord k, GHC.Classes.Ord p, GHC.Classes.Ord (Data.Patch.Class.PatchTarget p)) => GHC.Classes.Ord (Data.Patch.MapWithPatchingMove.NodeInfo k p)
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)
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)
instance (GHC.Classes.Eq k, GHC.Classes.Eq p, GHC.Classes.Eq (Data.Patch.Class.PatchTarget p)) => GHC.Classes.Eq (Data.Patch.MapWithPatchingMove.From k p)
instance (GHC.Classes.Ord k, GHC.Classes.Ord p, GHC.Classes.Ord (Data.Patch.Class.PatchTarget p)) => GHC.Classes.Ord (Data.Patch.MapWithPatchingMove.From k p)
instance (GHC.Classes.Ord k, Data.Monoid.DecidablyEmpty.DecidablyEmpty p, Data.Patch.Class.Patch p) => GHC.Base.Semigroup (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)
instance (GHC.Classes.Ord k, Data.Patch.Class.Patch p) => Data.Patch.Class.Patch (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)
instance (GHC.Classes.Ord k, Data.Monoid.DecidablyEmpty.DecidablyEmpty p, Data.Patch.Class.Patch p) => GHC.Base.Monoid (Data.Patch.MapWithPatchingMove.PatchMapWithPatchingMove k p)


-- | Patches of this type can insert, delete, and also move values from one
--   key to another.
module Data.Patch.MapWithMove

-- | Patch a Map with additions, deletions, and moves. Invariant: If key
--   <tt>k1</tt> is coming from <tt>From_Move k2</tt>, then key <tt>k2</tt>
--   should be going to <tt>Just k1</tt>, and vice versa. There should
--   never be any unpaired From/To keys.
newtype PatchMapWithMove k (v :: Type)
PatchMapWithMove' :: PatchMapWithPatchingMove k (Proxy v) -> PatchMapWithMove k (v :: Type)

-- | Extract the underlying 'PatchMapWithPatchingMove k (Proxy v)'
[unPatchMapWithMove'] :: PatchMapWithMove k (v :: Type) -> PatchMapWithPatchingMove k (Proxy v)
pattern PatchMapWithMove :: Map k (NodeInfo k v) -> PatchMapWithMove k v

-- | Create a <a>PatchMapWithMove</a>, validating it
patchMapWithMove :: Ord k => Map k (NodeInfo k v) -> Maybe (PatchMapWithMove k v)

-- | Create a <a>PatchMapWithMove</a> that inserts everything in the given
--   <a>Map</a>
patchMapWithMoveInsertAll :: Map k v -> PatchMapWithMove k v

-- | Make a <tt><a>PatchMapWithMove</a> k v</tt> which has the effect of
--   inserting or updating a value <tt>v</tt> to the given key <tt>k</tt>,
--   like <a>insert</a>.
insertMapKey :: k -> v -> PatchMapWithMove k v

-- | Make a <tt><a>PatchMapWithMove</a> k v</tt> which has the effect of
--   moving the value from the first key <tt>k</tt> to the second key
--   <tt>k</tt>, equivalent to:
--   
--   <pre>
--   <a>delete</a> src (maybe map (<a>insert</a> dst) (Map.lookup src map))
--   </pre>
moveMapKey :: Ord k => k -> k -> PatchMapWithMove k v

-- | Make a <tt><a>PatchMapWithMove</a> k v</tt> which has the effect of
--   swapping two keys in the mapping, equivalent to:
--   
--   <pre>
--   let aMay = Map.lookup a map
--       bMay = Map.lookup b map
--   in maybe id (Map.insert a) (bMay &lt;&gt; aMay)
--    . maybe id (Map.insert b) (aMay &lt;&gt; bMay)
--    . Map.delete a . Map.delete b $ map
--   </pre>
swapMapKey :: Ord k => k -> k -> PatchMapWithMove k v

-- | Make a <tt><a>PatchMapWithMove</a> k v</tt> which has the effect of
--   deleting a key in the mapping, equivalent to <a>delete</a>.
deleteMapKey :: k -> PatchMapWithMove k v

-- | Wrap a <tt><a>Map</a> k (NodeInfo k v)</tt> representing patch changes
--   into a <tt><a>PatchMapWithMove</a> k v</tt>, without checking any
--   invariants.
--   
--   <b>Warning:</b> when using this function, you must ensure that the
--   invariants of <a>PatchMapWithMove</a> are preserved; they will not be
--   checked.
unsafePatchMapWithMove :: Map k (NodeInfo k v) -> PatchMapWithMove k v

-- | Returns all the new elements that will be added to the <a>Map</a>.
patchMapWithMoveNewElements :: PatchMapWithMove k v -> [v]

-- | Return a <tt><a>Map</a> k v</tt> with all the inserts/updates from the
--   given <tt><a>PatchMapWithMove</a> k v</tt>.
patchMapWithMoveNewElementsMap :: PatchMapWithMove k v -> Map k v

-- | Create a <a>PatchMapWithMove</a> that, if applied to the given
--   <a>Map</a>, will sort its values using the given ordering function.
--   The set keys of the <a>Map</a> is not changed.
patchThatSortsMapWith :: Ord k => (v -> v -> Ordering) -> Map k v -> PatchMapWithMove k v

-- | Create a <a>PatchMapWithMove</a> that, if applied to the first
--   <a>Map</a> provided, will produce a <a>Map</a> with the same values as
--   the second <a>Map</a> but with the values sorted with the given
--   ordering function.
patchThatChangesAndSortsMapWith :: (Ord k, Ord v) => (v -> v -> Ordering) -> Map k v -> Map k v -> PatchMapWithMove k v

-- | Create a <a>PatchMapWithMove</a> that, if applied to the first
--   <a>Map</a> provided, will produce the second <a>Map</a>.
patchThatChangesMap :: (Ord k, Ord v) => Map k v -> Map k v -> PatchMapWithMove k v

-- | Holds the information about each key: where its new value should come
--   from, and where its old value should go to
newtype NodeInfo k (v :: Type)
NodeInfo' :: NodeInfo k (Proxy v) -> NodeInfo k (v :: Type)
[unNodeInfo'] :: NodeInfo k (v :: Type) -> NodeInfo k (Proxy v)
pattern NodeInfo :: From k v -> To k -> NodeInfo k v

-- | Like <a>bitraverse</a>
bitraverseNodeInfo :: Applicative f => (k0 -> f k1) -> (v0 -> f v1) -> NodeInfo k0 v0 -> f (NodeInfo k1 v1)

-- | Change the <a>From</a> value of a <a>NodeInfo</a>
nodeInfoMapFrom :: (From k v -> From k v) -> NodeInfo k v -> NodeInfo k v

-- | Change the <a>From</a> value of a <a>NodeInfo</a>, using a
--   <a>Functor</a> (or <a>Applicative</a>, <a>Monad</a>, etc.) action to
--   get the new value
nodeInfoMapMFrom :: Functor f => (From k v -> f (From k v)) -> NodeInfo k v -> f (NodeInfo k v)

-- | Set the <a>To</a> field of a <a>NodeInfo</a>
nodeInfoSetTo :: To k -> NodeInfo k v -> NodeInfo k v

-- | Describe how a key's new value should be produced
newtype From k (v :: Type)
From' :: From k (Proxy v) -> From k (v :: Type)
[unFrom'] :: From k (v :: Type) -> From k (Proxy v)

-- | Insert the given value here
pattern From_Insert :: v -> From k v

-- | Delete the existing value, if any, from here
pattern From_Delete :: From k v

-- | Move the value here from the given key
pattern From_Move :: k -> From k v

-- | Like <a>bitraverse</a>
bitraverseFrom :: Applicative f => (k0 -> f k1) -> (v0 -> f v1) -> From k0 v0 -> f (From k1 v1)

-- | Describe where a key's old value will go. If this is <a>Just</a>, that
--   means the key's old value will be moved to the given other key; if it
--   is <a>Nothing</a>, that means it will be deleted.
type To = Maybe
instance (Data.Patch.MapWithMove.From k1 v1 GHC.Types.~ t) => Control.Lens.Wrapped.Rewrapped (Data.Patch.MapWithMove.From k2 v2) t
instance Control.Lens.Wrapped.Wrapped (Data.Patch.MapWithMove.From k v)
instance (Data.Patch.MapWithMove.NodeInfo k1 v1 GHC.Types.~ t) => Control.Lens.Wrapped.Rewrapped (Data.Patch.MapWithMove.NodeInfo k2 v2) t
instance Control.Lens.Wrapped.Wrapped (Data.Patch.MapWithMove.NodeInfo k v)
instance (Data.Patch.MapWithMove.PatchMapWithMove k1 v1 GHC.Types.~ t) => Control.Lens.Wrapped.Rewrapped (Data.Patch.MapWithMove.PatchMapWithMove k2 v2) t
instance Control.Lens.Wrapped.Wrapped (Data.Patch.MapWithMove.PatchMapWithMove k v)
instance GHC.Classes.Ord k => GHC.Base.Monoid (Data.Patch.MapWithMove.PatchMapWithMove k v)
instance GHC.Classes.Ord k => GHC.Base.Semigroup (Data.Patch.MapWithMove.PatchMapWithMove k v)
instance (GHC.Classes.Ord k, GHC.Classes.Ord v) => GHC.Classes.Ord (Data.Patch.MapWithMove.PatchMapWithMove k v)
instance (GHC.Classes.Eq k, GHC.Classes.Eq v) => GHC.Classes.Eq (Data.Patch.MapWithMove.PatchMapWithMove k v)
instance (GHC.Classes.Ord k, GHC.Read.Read k, GHC.Read.Read v) => GHC.Read.Read (Data.Patch.MapWithMove.PatchMapWithMove k v)
instance (GHC.Show.Show k, GHC.Show.Show v) => GHC.Show.Show (Data.Patch.MapWithMove.PatchMapWithMove k v)
instance (GHC.Show.Show k, GHC.Show.Show p) => GHC.Show.Show (Data.Patch.MapWithMove.NodeInfo k p)
instance (GHC.Read.Read k, GHC.Read.Read p) => GHC.Read.Read (Data.Patch.MapWithMove.NodeInfo k p)
instance (GHC.Classes.Eq k, GHC.Classes.Eq p) => GHC.Classes.Eq (Data.Patch.MapWithMove.NodeInfo k p)
instance (GHC.Classes.Ord k, GHC.Classes.Ord p) => GHC.Classes.Ord (Data.Patch.MapWithMove.NodeInfo k p)
instance GHC.Base.Functor (Data.Patch.MapWithMove.NodeInfo k)
instance Data.Foldable.Foldable (Data.Patch.MapWithMove.NodeInfo k)
instance Data.Traversable.Traversable (Data.Patch.MapWithMove.NodeInfo k)
instance GHC.Base.Functor (Data.Patch.MapWithMove.PatchMapWithMove k)
instance Data.Foldable.Foldable (Data.Patch.MapWithMove.PatchMapWithMove k)
instance Data.Traversable.Traversable (Data.Patch.MapWithMove.PatchMapWithMove k)
instance WithIndex.FunctorWithIndex k (Data.Patch.MapWithMove.PatchMapWithMove k)
instance WithIndex.FoldableWithIndex k (Data.Patch.MapWithMove.PatchMapWithMove k)
instance WithIndex.TraversableWithIndex k (Data.Patch.MapWithMove.PatchMapWithMove k)
instance GHC.Classes.Ord k => Data.Patch.Class.Patch (Data.Patch.MapWithMove.PatchMapWithMove k v)


-- | This Module contains <tt><a>PatchDMapWithMove</a> k v</tt> and
--   associated functions, which represents a <a>Patch</a> to a
--   <tt><a>DMap</a> k v</tt> which can insert, update, delete, and move
--   values between keys.
module Data.Patch.DMapWithMove

-- | Like <a>PatchMapWithMove</a>, but for <a>DMap</a>. Each key carries a
--   <a>NodeInfo</a> which describes how it will be changed by the patch
--   and connects move sources and destinations.
--   
--   Invariants:
--   
--   <ul>
--   <li>A key should not move to itself.</li>
--   <li>A move should always be represented with both the destination key
--   (as a <a>From_Move</a>) and the source key (as a
--   <tt><a>ComposeMaybe</a> (<a>Just</a> destination)</tt>)</li>
--   </ul>
newtype PatchDMapWithMove k v
PatchDMapWithMove :: DMap k (NodeInfo k v) -> PatchDMapWithMove k v

-- | Structure which represents what changes apply to a particular key.
--   <tt>_nodeInfo_from</tt> specifies what happens to this key, and in
--   particular what other key the current key is moving from, while
--   <tt>_nodeInfo_to</tt> specifies what key the current key is moving to
--   if involved in a move.
data NodeInfo k v a
NodeInfo :: !From k v a -> !To k a -> NodeInfo k v a

-- | Change applying to the current key, be it an insert, move, or delete.
[_nodeInfo_from] :: NodeInfo k v a -> !From k v a

-- | Where this key is moving to, if involved in a move. Should only be
--   <tt>ComposeMaybe (Just k)</tt> when there is a corresponding
--   <a>From_Move</a>.
[_nodeInfo_to] :: NodeInfo k v a -> !To k a

-- | Structure describing a particular change to a key, be it inserting a
--   new key (<tt>From_Insert</tt>), updating an existing key
--   (<tt>From_Insert</tt> again), deleting a key (<tt>From_Delete</tt>),
--   or moving a key (<tt>From_Move</tt>).
data From (k :: a -> Type) (v :: a -> Type) :: a -> Type

-- | Insert a new or update an existing key with the given value <tt>v
--   a</tt>
[From_Insert] :: v a -> From k v a

-- | Delete the existing key
[From_Delete] :: From k v a

-- | Move the value from the given key <tt>k a</tt> to this key. The source
--   key should also have an entry in the patch giving the current key as
--   <tt>_nodeInfo_to</tt>, usually but not necessarily with
--   <tt>From_Delete</tt>.
[From_Move] :: !k a -> From k v a

-- | Type alias for the "to" part of a <a>NodeInfo</a>.
--   <tt><a>ComposeMaybe</a> (<a>Just</a> k)</tt> means the key is moving
--   to another key, <tt>ComposeMaybe Nothing</tt> for any other operation.
type To = ComposeMaybe

-- | Test whether a <a>PatchDMapWithMove</a> satisfies its invariants.
validPatchDMapWithMove :: forall k v. (GCompare k, GShow k) => DMap k (NodeInfo k v) -> Bool

-- | Enumerate what reasons a <a>PatchDMapWithMove</a> doesn't satisfy its
--   invariants, returning <tt>[]</tt> if it's valid.
validationErrorsForPatchDMapWithMove :: forall k v. (GCompare k, GShow k) => DMap k (NodeInfo k v) -> [String]

-- | Higher kinded 2-tuple, identical to <tt>Data.Functor.Product</tt> from
--   base ≥ 4.9
data Pair1 f g a
Pair1 :: f a -> g a -> Pair1 f g a

-- | Helper data structure used for composing patches using the monoid
--   instance.
data Fixup k v a
Fixup_Delete :: Fixup k v a
Fixup_Update :: These (From k v a) (To k a) -> Fixup k v a

-- | Make a <tt><a>PatchDMapWithMove</a> k v</tt> which has the effect of
--   inserting or updating a value <tt>v a</tt> to the given key <tt>k
--   a</tt>, like <a>insert</a>.
insertDMapKey :: k a -> v a -> PatchDMapWithMove k v

-- | Make a <tt><a>PatchDMapWithMove</a> k v</tt> which has the effect of
--   moving the value from the first key <tt>k a</tt> to the second key
--   <tt>k a</tt>, equivalent to:
--   
--   <pre>
--   <a>delete</a> src (maybe dmap (<a>insert</a> dst) (DMap.lookup src dmap))
--   </pre>
moveDMapKey :: GCompare k => k a -> k a -> PatchDMapWithMove k v

-- | Make a <tt><a>PatchDMapWithMove</a> k v</tt> which has the effect of
--   swapping two keys in the mapping, equivalent to:
--   
--   <pre>
--   let aMay = DMap.lookup a dmap
--       bMay = DMap.lookup b dmap
--   in maybe id (DMap.insert a) (bMay &lt;&gt; aMay)
--    . maybe id (DMap.insert b) (aMay &lt;&gt; bMay)
--    . DMap.delete a . DMap.delete b $ dmap
--   </pre>
swapDMapKey :: GCompare k => k a -> k a -> PatchDMapWithMove k v

-- | Make a <tt><a>PatchDMapWithMove</a> k v</tt> which has the effect of
--   deleting a key in the mapping, equivalent to <a>delete</a>.
deleteDMapKey :: k a -> PatchDMapWithMove k v

-- | Extract the <a>DMap</a> representing the patch changes from the
--   <a>PatchDMapWithMove</a>.
unPatchDMapWithMove :: PatchDMapWithMove k v -> DMap k (NodeInfo k v)

-- | Wrap a <a>DMap</a> representing patch changes into a
--   <a>PatchDMapWithMove</a>, without checking any invariants.
--   
--   <b>Warning:</b> when using this function, you must ensure that the
--   invariants of <a>PatchDMapWithMove</a> are preserved; they will not be
--   checked.
unsafePatchDMapWithMove :: DMap k (NodeInfo k v) -> PatchDMapWithMove k v

-- | Wrap a <a>DMap</a> representing patch changes into a
--   <a>PatchDMapWithMove</a> while checking invariants. If the invariants
--   are satisfied, <tt>Right p</tt> is returned otherwise <tt>Left
--   errors</tt>.
patchDMapWithMove :: (GCompare k, GShow k) => DMap k (NodeInfo k v) -> Either [String] (PatchDMapWithMove k v)

-- | Map a natural transform <tt>v -&gt; v'</tt> over the given patch,
--   transforming <tt><a>PatchDMapWithMove</a> k v</tt> into
--   <tt><a>PatchDMapWithMove</a> k v'</tt>.
mapPatchDMapWithMove :: forall k v v'. (forall a. v a -> v' a) -> PatchDMapWithMove k v -> PatchDMapWithMove k v'

-- | Traverse an effectful function <tt>forall a. v a -&gt; m (v ' a)</tt>
--   over the given patch, transforming <tt><a>PatchDMapWithMove</a> k
--   v</tt> into <tt>m (<a>PatchDMapWithMove</a> k v')</tt>.
traversePatchDMapWithMove :: forall m k v v'. Applicative m => (forall a. v a -> m (v' a)) -> PatchDMapWithMove k v -> m (PatchDMapWithMove k v')

-- | Map an effectful function <tt>forall a. k a -&gt; v a -&gt; m (v '
--   a)</tt> over the given patch, transforming
--   <tt><a>PatchDMapWithMove</a> k v</tt> into <tt>m
--   (<a>PatchDMapWithMove</a> k v')</tt>.
traversePatchDMapWithMoveWithKey :: forall m k v v'. Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMapWithMove k v -> m (PatchDMapWithMove k v')

-- | Map a function which transforms <tt><a>From</a> k v a</tt> into a
--   <tt><a>From</a> k v' a</tt> over a <tt><a>NodeInfo</a> k v a</tt>.
nodeInfoMapFrom :: (From k v a -> From k v' a) -> NodeInfo k v a -> NodeInfo k v' a

-- | Map an effectful function which transforms <tt><a>From</a> k v a</tt>
--   into a <tt>f (<a>From</a> k v' a)</tt> over a <tt><a>NodeInfo</a> k v
--   a</tt>.
nodeInfoMapFromM :: Functor f => (From k v a -> f (From k v' a)) -> NodeInfo k v a -> f (NodeInfo k v' a)

-- | Weaken a <a>PatchDMapWithMove</a> to a <a>PatchMapWithMove</a> by
--   weakening the keys from <tt>k a</tt> to <tt><a>Some</a> k</tt> and
--   applying a given weakening function <tt>v a -&gt; v'</tt> to values.
weakenPatchDMapWithMoveWith :: forall k v v'. (forall a. v a -> v') -> PatchDMapWithMove k v -> PatchMapWithMove (Some k) v'

-- | <a>Weaken</a> a <tt><a>PatchDMapWithMove</a> (Const2 k a) v</tt> to a
--   <tt><a>PatchMapWithMove</a> k v'</tt>. Weaken is in scare quotes
--   because the <a>Const2</a> has already disabled any dependency in the
--   typing and all points are already <tt>a</tt>, hence the function to
--   map each value to <tt>v'</tt> is not higher rank.
patchDMapWithMoveToPatchMapWithMoveWith :: forall k v v' a. (v a -> v') -> PatchDMapWithMove (Const2 k a) v -> PatchMapWithMove k v'

-- | <a>Strengthen</a> a <tt><a>PatchMapWithMove</a> k v</tt> into a
--   <tt>'PatchDMapWithMove (<a>Const2</a> k a)</tt>; that is, turn a
--   non-dependently-typed patch into a dependently typed one but which
--   always has a constant key type represented by <a>Const2</a>. Apply the
--   given function to each <tt>v</tt> to produce a <tt>v' a</tt>.
--   Completemented by <a>patchDMapWithMoveToPatchMapWithMoveWith</a>
const2PatchDMapWithMoveWith :: forall k v v' a. (v -> v' a) -> PatchMapWithMove k v -> PatchDMapWithMove (Const2 k a) v'

-- | Get the values that will be replaced, deleted, or moved if the given
--   patch is applied to the given <a>DMap</a>.
getDeletionsAndMoves :: GCompare k => PatchDMapWithMove k v -> DMap k v' -> DMap k (Product v' (ComposeMaybe k))
instance forall a (k :: a -> *) (v :: a -> *) (b :: a). (GHC.Classes.Ord (v b), GHC.Classes.Ord (k b)) => GHC.Classes.Ord (Data.Patch.DMapWithMove.From k v b)
instance forall a (k :: a -> *) (v :: a -> *) (b :: a). (GHC.Classes.Eq (v b), GHC.Classes.Eq (k b)) => GHC.Classes.Eq (Data.Patch.DMapWithMove.From k v b)
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)
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)
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)
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Base.Semigroup (Data.Patch.DMapWithMove.PatchDMapWithMove k2 v)
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => Data.Monoid.DecidablyEmpty.DecidablyEmpty (Data.Patch.DMapWithMove.PatchDMapWithMove k2 v)
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). (Data.GADT.Internal.GEq k2, Data.Constraint.Extras.Has' GHC.Classes.Eq k2 (Data.Patch.DMapWithMove.NodeInfo k2 v)) => GHC.Classes.Eq (Data.Patch.DMapWithMove.PatchDMapWithMove k2 v)
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => GHC.Base.Monoid (Data.Patch.DMapWithMove.PatchDMapWithMove k2 v)
instance forall k1 (k2 :: k1 -> *) (v :: k1 -> *). Data.GADT.Internal.GCompare k2 => Data.Patch.Class.Patch (Data.Patch.DMapWithMove.PatchDMapWithMove k2 v)



-- | <i>Deprecated: Use <a>Commutative</a></i>
module Data.Semigroup.Additive

-- | Deprecated alias for <a>Commutative</a>
type Additive = Commutative


module Data.Patch

-- | The elements of an <a>Commutative</a> <a>Semigroup</a> can be
--   considered as patches of their own type.
newtype AdditivePatch p
AdditivePatch :: p -> AdditivePatch p
[unAdditivePatch] :: AdditivePatch p -> p

-- | A <a>Group</a> is a <a>Monoid</a> where every element has an inverse.
class (Semigroup q, Monoid q) => Group q
negateG :: Group q => q -> q
(~~) :: Group q => q -> q -> q

-- | A <a>Patch</a> type represents a kind of change made to a
--   datastructure.
--   
--   If an instance of <a>Patch</a> is also an instance of
--   <a>Semigroup</a>, it should obey the law that <tt>applyAlways (f
--   &lt;&gt; g) == applyAlways f . applyAlways g</tt>.
class Patch p where {
    type family PatchTarget p :: Type;
}

-- | Apply the patch <tt>p a</tt> to the value <tt>a</tt>. If no change is
--   needed, return <a>Nothing</a>.
apply :: Patch p => p -> PatchTarget p -> Maybe (PatchTarget p)

-- | Apply a <a>Patch</a>; if it does nothing, return the original value
applyAlways :: Patch p => p -> PatchTarget p -> PatchTarget p

-- | Like <a>(.)</a>, but composes functions that return patches rather
--   than functions that return new values. The Semigroup instance for
--   patches must apply patches right-to-left, like <a>(.)</a>.
composePatchFunctions :: (Patch p, Semigroup p) => (PatchTarget p -> p) -> (PatchTarget p -> p) -> PatchTarget p -> p

-- | <a>Patch</a> for <a>IntMap</a> which represents insertion or deletion
--   of keys in the mapping. Internally represented by 'IntMap (Maybe a)',
--   where <tt>Just</tt> means insert/update and <tt>Nothing</tt> means
--   delete.
newtype PatchIntMap a
PatchIntMap :: IntMap (Maybe a) -> PatchIntMap a
[unPatchIntMap] :: PatchIntMap a -> IntMap (Maybe a)

-- | Map a function <tt>Int -&gt; a -&gt; b</tt> over all <tt>a</tt>s in
--   the given <tt><a>PatchIntMap</a> a</tt> (that is, all
--   inserts/updates), producing a <tt>PatchIntMap b</tt>.
mapIntMapPatchWithKey :: (Int -> a -> b) -> PatchIntMap a -> PatchIntMap b

-- | Map an effectful function <tt>Int -&gt; a -&gt; f b</tt> over all
--   <tt>a</tt>s in the given <tt><a>PatchIntMap</a> a</tt> (that is, all
--   inserts/updates), producing a <tt>f (PatchIntMap b)</tt>.
traverseIntMapPatchWithKey :: Applicative f => (Int -> a -> f b) -> PatchIntMap a -> f (PatchIntMap b)

-- | Extract all <tt>a</tt>s inserted/updated by the given
--   <tt><a>PatchIntMap</a> a</tt>.
patchIntMapNewElements :: PatchIntMap a -> [a]

-- | Convert the given <tt><a>PatchIntMap</a> a</tt> into an
--   <tt><a>IntMap</a> a</tt> with all the inserts/updates in the given
--   patch.
patchIntMapNewElementsMap :: PatchIntMap a -> IntMap a

-- | A set of changes to a <a>Map</a>. Any element may be inserted/updated
--   or deleted. Insertions are represented as values wrapped in
--   <a>Just</a>, while deletions are represented as <a>Nothing</a>s
newtype PatchMap k v
PatchMap :: Map k (Maybe v) -> PatchMap k v
[unPatchMap] :: PatchMap k v -> Map k (Maybe v)

-- | Returns all the new elements that will be added to the <a>Map</a>
patchMapNewElements :: PatchMap k v -> [v]

-- | Returns all the new elements that will be added to the <a>Map</a>
patchMapNewElementsMap :: PatchMap k v -> Map k v

-- | A set of changes to a <a>DMap</a>. Any element may be inserted/updated
--   or deleted. Insertions are represented as <tt><a>ComposeMaybe</a>
--   (Just value)</tt>, while deletions are represented as
--   <tt><a>ComposeMaybe</a> Nothing</tt>.
newtype PatchDMap k v
PatchDMap :: DMap k (ComposeMaybe v) -> PatchDMap k v
[unPatchDMap] :: PatchDMap k v -> DMap k (ComposeMaybe v)

-- | Map a function <tt>v a -&gt; v' a</tt> over any inserts/updates in the
--   given <tt><a>PatchDMap</a> k v</tt> to produce a <tt><a>PatchDMap</a>
--   k v'</tt>.
mapPatchDMap :: (forall a. v a -> v' a) -> PatchDMap k v -> PatchDMap k v'

-- | Map an effectful function <tt>v a -&gt; f (v' a)</tt> over any
--   inserts/updates in the given <tt><a>PatchDMap</a> k v</tt> to produce
--   a <tt><a>PatchDMap</a> k v'</tt>.
traversePatchDMap :: Applicative f => (forall a. v a -> f (v' a)) -> PatchDMap k v -> f (PatchDMap k v')

-- | Map an effectful function <tt>k a -&gt; v a -&gt; f (v' a)</tt> over
--   any inserts/updates in the given <tt><a>PatchDMap</a> k v</tt> to
--   produce a <tt><a>PatchDMap</a> k v'</tt>.
traversePatchDMapWithKey :: Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMap k v -> m (PatchDMap k v')

-- | Weaken a <tt><a>PatchDMap</a> k v</tt> to a <tt><a>PatchMap</a> (Some
--   k) v'</tt> using a function <tt>v a -&gt; v'</tt> to weaken each value
--   contained in the patch.
weakenPatchDMapWith :: (forall a. v a -> v') -> PatchDMap k v -> PatchMap (Some k) v'

-- | Convert a weak <tt><a>PatchDMap</a> (<a>Const2</a> k a) v</tt> where
--   the <tt>a</tt> is known by way of the <tt>Const2</tt> into a
--   <tt><a>PatchMap</a> k v'</tt> using a rank 1 function <tt>v a -&gt;
--   v'</tt>.
patchDMapToPatchMapWith :: (v a -> v') -> PatchDMap (Const2 k a) v -> PatchMap k v'

-- | Convert a <tt><a>PatchMap</a> k v</tt> into a <tt><a>PatchDMap</a>
--   (<a>Const2</a> k a) v'</tt> using a function <tt>v -&gt; v' a</tt>.
const2PatchDMapWith :: forall k v v' a. (v -> v' a) -> PatchMap k v -> PatchDMap (Const2 k a) v'

-- | Convert a <tt><a>PatchIntMap</a> v</tt> into a <tt><a>PatchDMap</a>
--   (<a>Const2</a> Int a) v'</tt> using a function <tt>v -&gt; v' a</tt>.
const2IntPatchDMapWith :: forall v f a. (v -> f a) -> PatchIntMap v -> PatchDMap (Const2 Key a) f

-- | Patch a Map with additions, deletions, and moves. Invariant: If key
--   <tt>k1</tt> is coming from <tt>From_Move k2</tt>, then key <tt>k2</tt>
--   should be going to <tt>Just k1</tt>, and vice versa. There should
--   never be any unpaired From/To keys.
data PatchMapWithMove k (v :: Type)

-- | Wrap a <tt><a>Map</a> k (NodeInfo k v)</tt> representing patch changes
--   into a <tt><a>PatchMapWithMove</a> k v</tt>, without checking any
--   invariants.
--   
--   <b>Warning:</b> when using this function, you must ensure that the
--   invariants of <a>PatchMapWithMove</a> are preserved; they will not be
--   checked.
unsafePatchMapWithMove :: Map k (NodeInfo k v) -> PatchMapWithMove k v

-- | Returns all the new elements that will be added to the <a>Map</a>.
patchMapWithMoveNewElements :: PatchMapWithMove k v -> [v]

-- | Return a <tt><a>Map</a> k v</tt> with all the inserts/updates from the
--   given <tt><a>PatchMapWithMove</a> k v</tt>.
patchMapWithMoveNewElementsMap :: PatchMapWithMove k v -> Map k v

-- | Like <a>PatchMapWithMove</a>, but for <a>DMap</a>. Each key carries a
--   <a>NodeInfo</a> which describes how it will be changed by the patch
--   and connects move sources and destinations.
--   
--   Invariants:
--   
--   <ul>
--   <li>A key should not move to itself.</li>
--   <li>A move should always be represented with both the destination key
--   (as a <a>From_Move</a>) and the source key (as a
--   <tt><a>ComposeMaybe</a> (<a>Just</a> destination)</tt>)</li>
--   </ul>
data PatchDMapWithMove k v

-- | Extract the <a>DMap</a> representing the patch changes from the
--   <a>PatchDMapWithMove</a>.
unPatchDMapWithMove :: PatchDMapWithMove k v -> DMap k (NodeInfo k v)

-- | Wrap a <a>DMap</a> representing patch changes into a
--   <a>PatchDMapWithMove</a>, without checking any invariants.
--   
--   <b>Warning:</b> when using this function, you must ensure that the
--   invariants of <a>PatchDMapWithMove</a> are preserved; they will not be
--   checked.
unsafePatchDMapWithMove :: DMap k (NodeInfo k v) -> PatchDMapWithMove k v

-- | Map a natural transform <tt>v -&gt; v'</tt> over the given patch,
--   transforming <tt><a>PatchDMapWithMove</a> k v</tt> into
--   <tt><a>PatchDMapWithMove</a> k v'</tt>.
mapPatchDMapWithMove :: forall k v v'. (forall a. v a -> v' a) -> PatchDMapWithMove k v -> PatchDMapWithMove k v'

-- | Map an effectful function <tt>forall a. k a -&gt; v a -&gt; m (v '
--   a)</tt> over the given patch, transforming
--   <tt><a>PatchDMapWithMove</a> k v</tt> into <tt>m
--   (<a>PatchDMapWithMove</a> k v')</tt>.
traversePatchDMapWithMoveWithKey :: forall m k v v'. Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMapWithMove k v -> m (PatchDMapWithMove k v')

-- | Weaken a <a>PatchDMapWithMove</a> to a <a>PatchMapWithMove</a> by
--   weakening the keys from <tt>k a</tt> to <tt><a>Some</a> k</tt> and
--   applying a given weakening function <tt>v a -&gt; v'</tt> to values.
weakenPatchDMapWithMoveWith :: forall k v v'. (forall a. v a -> v') -> PatchDMapWithMove k v -> PatchMapWithMove (Some k) v'

-- | <a>Weaken</a> a <tt><a>PatchDMapWithMove</a> (Const2 k a) v</tt> to a
--   <tt><a>PatchMapWithMove</a> k v'</tt>. Weaken is in scare quotes
--   because the <a>Const2</a> has already disabled any dependency in the
--   typing and all points are already <tt>a</tt>, hence the function to
--   map each value to <tt>v'</tt> is not higher rank.
patchDMapWithMoveToPatchMapWithMoveWith :: forall k v v' a. (v a -> v') -> PatchDMapWithMove (Const2 k a) v -> PatchMapWithMove k v'

-- | <a>Strengthen</a> a <tt><a>PatchMapWithMove</a> k v</tt> into a
--   <tt>'PatchDMapWithMove (<a>Const2</a> k a)</tt>; that is, turn a
--   non-dependently-typed patch into a dependently typed one but which
--   always has a constant key type represented by <a>Const2</a>. Apply the
--   given function to each <tt>v</tt> to produce a <tt>v' a</tt>.
--   Completemented by <a>patchDMapWithMoveToPatchMapWithMoveWith</a>
const2PatchDMapWithMoveWith :: forall k v v' a. (v -> v' a) -> PatchMapWithMove k v -> PatchDMapWithMove (Const2 k a) v'
instance forall k a (x :: k). Data.Patch.Group a => Data.Patch.Group (Data.Functor.Const.Const a x)
instance Data.Patch.Group a => Data.Patch.Group (Data.Functor.Identity.Identity a)
instance Data.Semigroup.Commutative.Commutative p => Data.Patch.Class.Patch (Data.Patch.AdditivePatch p)
instance (GHC.Classes.Ord k, Data.Patch.Group q) => Data.Patch.Group (Data.Map.Monoidal.MonoidalMap k q)
instance Data.Patch.Group ()
instance (Data.Patch.Group a, Data.Patch.Group b) => Data.Patch.Group (a, b)
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)
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)
instance forall k (x :: k). Data.Patch.Group (Data.Proxy.Proxy x)
instance Data.Patch.Group b => Data.Patch.Group (a -> b)


module Data.Patch.PatchOrReplacement

-- | Either a patch or a replacement value.
--   
--   A good patch type will describe small changes very efficiently, but
--   that often comes at the cost of describing large change rather
--   inefficiently. <a>PatchOrReplacement</a> can be used as an escape
--   hatch: when the change as a patch would be too big, just provide a new
--   value to replace the old one with instead.
data PatchOrReplacement p
PatchOrReplacement_Patch :: p -> PatchOrReplacement p
PatchOrReplacement_Replacement :: PatchTarget p -> PatchOrReplacement p
_PatchOrReplacement_Patch :: forall p_aF9n. Prism' (PatchOrReplacement p_aF9n) p_aF9n
_PatchOrReplacement_Replacement :: forall p_aF9n. Prism' (PatchOrReplacement p_aF9n) (PatchTarget p_aF9n)

-- | Traverse a <a>PatchOrReplacement</a> with a function for each case
traversePatchOrReplacement :: Functor f => (a -> f b) -> (PatchTarget a -> f (PatchTarget b)) -> PatchOrReplacement a -> f (PatchOrReplacement b)
instance GHC.Generics.Generic (Data.Patch.PatchOrReplacement.PatchOrReplacement p)
instance (GHC.Classes.Eq p, GHC.Classes.Eq (Data.Patch.Class.PatchTarget p)) => GHC.Classes.Eq (Data.Patch.PatchOrReplacement.PatchOrReplacement p)
instance (GHC.Classes.Ord p, GHC.Classes.Ord (Data.Patch.Class.PatchTarget p)) => GHC.Classes.Ord (Data.Patch.PatchOrReplacement.PatchOrReplacement p)
instance (GHC.Show.Show p, GHC.Show.Show (Data.Patch.Class.PatchTarget p)) => GHC.Show.Show (Data.Patch.PatchOrReplacement.PatchOrReplacement p)
instance (GHC.Read.Read p, GHC.Read.Read (Data.Patch.Class.PatchTarget p)) => GHC.Read.Read (Data.Patch.PatchOrReplacement.PatchOrReplacement p)
instance Data.Patch.Class.Patch p => Data.Patch.Class.Patch (Data.Patch.PatchOrReplacement.PatchOrReplacement p)
instance (GHC.Base.Monoid p, Data.Patch.Class.Patch p) => GHC.Base.Monoid (Data.Patch.PatchOrReplacement.PatchOrReplacement p)
instance (GHC.Base.Semigroup p, Data.Patch.Class.Patch p) => GHC.Base.Semigroup (Data.Patch.PatchOrReplacement.PatchOrReplacement p)