!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe&'-124=>?@AHSX_g#fpatch We can't use  Compose Maybe instead of , because that would make the f` parameter have a nominal type role. We need f to be representational so that we can use safe coerce.patch Tag type for  to use it as a .patch can be used to tag a value in one functor with a type representing another functor. This was primarily used with dependent-map < 0.2, in which the value type was not wrapped in a separate functor.patch stores a value of a given type k% and ensures that a particular type v, is always given for the last type parameter patchExtract the value from a Const2 patch Convert a  to a regular  patch Convert a  to an  patch Convert a  to a regular 6, applying the given function to remove the wrapping patchConvert a regular  to a patchConvert a regular ;, where the values are already wrapped in a functor, to a patchConvert a regular ;, where the values are already wrapped in a functor, to a patch Convert a  to a regular \ by forgetting the types associated with the keys, using a function to remove the wrapping patch"Map over all key/value pairs in a , potentially altering the key as well as the value. The provided function MUST preserve the ordering of the keys, or the resulting  will be malformed.patch Union two zs of different types, yielding another type. Each key that is present in either input map will be present in the output.patchExtract the values of a  of s.patchConvert  to a  . Inverse of .patchConvert  to  . Inverse of .  SafeHV-.patchA .: type represents a kind of change made to a datastructure.If an instance of . is also an instance of , it should obey the law that 5applyAlways (f <> g) == applyAlways f . applyAlways g.0patchApply the patch p a to the value a#. If no change is needed, return .1patchApply a ./; if it does nothing, return the original value2patchLike '(.)', 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 '(.)'.3patch can be used as a .% that always fully replaces the value.0/12.0/12None456HMV=a4patch. for u which represents insertion or deletion of keys in the mapping. Internally represented by 'IntMap (Maybe a)', where Just means insert/update and Nothing means delete.6patchMap a function  Int -> a -> b over all as in the given 4 a. (that is, all inserts/updates), producing a  PatchIntMap b.7patchMap an effectful function Int -> a -> f b over all as in the given 4 a. (that is, all inserts/updates), producing a f (PatchIntMap b).8patch Extract all a s inserted/updated by the given 4 a.9patchConvert the given 4 a into an  a2 with all the inserts/updates in the given patch.:patchSubset the given  a> to contain only the keys that would be deleted by the given 4 a.;patcha <> b will apply the changes of b and then apply the changes of aZ. If the same key is modified by both patches, the one on the left will take precedence.<patch-Apply the insertions or deletions to a given .456789:456789:SafeHV_HApatchA set of changes to a e. Any element may be inserted/updated or deleted. Insertions are represented as values wrapped in &, while deletions are represented as sDpatch7Returns all the new elements that will be added to the Epatch7Returns all the new elements that will be added to the Fpatchping a AH will alter all of the values it will insert. Deletions are unaffected.Gpatch The empty A$ contains no insertions or deletionsHpatcha <> b will apply the changes of b and then apply the changes of aZ. If the same key is modified by both patches, the one on the left will take precedence.Ipatch-Apply the insertions or deletions to a given .ABCDEABCDENone -1HMSVX_Zv NpatchA set of changes to a R. Any element may be inserted/updated or deleted. Insertions are represented as  (Just value)&, while deletions are represented as  Nothing.QpatchMap a function  v a -> v' a( over any inserts/updates in the given N k v to produce a N k v'.RpatchMap an effectful function v a -> f (v' a)( over any inserts/updates in the given N k v to produce a N k v'.SpatchMap an effectful function k a -> v a -> f (v' a)( over any inserts/updates in the given N k v to produce a N k v'.Tpatch Weaken a N k v to a A (Some k) v' using a function  v a -> v'- to weaken each value contained in the patch.UpatchConvert a weak N ( k a) v where the a is known by way of the Const2 into a A k v' using a rank 1 function  v a -> v'.Vpatch Convert a A k v into a N ( k a) v' using a function  v -> v' a.Wpatch Convert a 4 v into a N ( Int a) v' using a function  v -> v' a.Xpatch[Get the values that will be replaced or deleted if the given patch is applied to the given .Ypatch-Apply the insertions or deletions to a given . NOPQRSTUVWX NOPQRSTUVWXSafe 456>HQVX_q\patchKHelper data structure used for composing patches using the monoid instance._patch6Describe where a key's old value will go. If this is Q, that means the key's old value will be moved to the given other key; if it is !, that means it will be deleted.`patch1Describe how a key's new value should be producedapatchInsert the given value herebpatch,Delete the existing value, if any, from herecpatch&Move the value here from the given keydpatchqHolds the information about each key: where its new value should come from, and where its old value should go tofpatch+Where do we get the new value for this key?gpatch`If the old value is being kept (i.e. moved rather than deleted or replaced), where is it going?hpatchFPatch a DMap with additions, deletions, and moves. Invariant: If key k1 is coming from  From_Move k2 , then key k2 should be going to Just k1D, and vice versa. There should never be any unpaired From/To keys.jpatch Create a h, validating itkpatch Create a h& that inserts everything in the given lpatch+Extract the internal representation of the hmpatchMake a h k v7 which has the effect of inserting or updating a value v to the given key k, like .npatchMake a h k v= which has the effect of moving the value from the first key k to the second key k, equivalent to:   src (maybe map ( dst) (Map.lookup src map)) opatchMake a h k vI which has the effect of swapping two keys in the mapping, equivalent to: e let aMay = Map.lookup a map bMay = Map.lookup b map in maybe id (Map.insert a) (bMay mplus, aMay) . maybe id (Map.insert b) (aMay mplus0 bMay) . Map.delete a . Map.delete b $ map ppatchMake a h k vF which has the effect of deleting a key in the mapping, equivalent to .qpatchWrap a  k (NodeInfo k v)# representing patch changes into a h k v", without checking any invariants.Warning:B when using this function, you must ensure that the invariants of h) are preserved; they will not be checked.rpatch7Returns all the new elements that will be added to the .spatch Return a  k v- with all the inserts/updates from the given h k v.tpatch Create a h that, if applied to the given P, will sort its values using the given ordering function. The set keys of the  is not changed.upatch Create a h that, if applied to the first  provided, will produce a $ with the same values as the second > but with the values sorted with the given ordering function.vpatch Create a h that, if applied to the first $ provided, will produce the second .wpatch Change the ` value of a dxpatch Change the ` value of a d , using a  (or , #, etc.) action to get the new valueypatchSet the _ field of a dzpatchHCompose patches having the same effect as applying the patches in turn: 1 (p <> q) == 1 p . 1 q{patch6Apply the insertions, deletions, and moves to a given |patchHCompose patches having the same effect as applying the patches in turn: 1 (p <> q) == 1 p . 1 q\^]_`cbadegfhijklmnopqrstuvwxyhidegf`cba_jklmnopqrstuvwxy\^]Safe&'-=>?@AHQSVX_ӧ!patchKHelper data structure used for composing patches using the monoid instance.patch$Higher kinded 2-tuple, identical to Data.Functor.Product from base "e 4.9patch"Type alias for the "to" part of a .  ( k)) means the key is moving to another key, ComposeMaybe Nothing for any other operation.patchNStructure describing a particular change to a key, be it inserting a new key ( From_Insert), updating an existing key ( From_Insert again), deleting a key ( From_Delete), or moving a key ( From_Move).patch<Insert a new or update an existing key with the given value v apatchDelete the existing keypatch"Move the value from the given key k a^ to this key. The source key should also have an entry in the patch giving the current key as  _nodeInfo_to$, usually but not necessarily with  From_Delete.patchCStructure which represents what changes apply to a particular key. _nodeInfo_fromm specifies what happens to this key, and in particular what other key the current key is moving from, while  _nodeInfo_toG specifies what key the current key is moving to if involved in a move.patchEChange applying to the current key, be it an insert, move, or delete.patchCWhere this key is moving to, if involved in a move. Should only be ComposeMaybe (Just k) when there is a corresponding .patchLike h , but for . Each key carries a a which describes how it will be changed by the patch and connects move sources and destinations. Invariants: A key should not move to itself.HA move should always be represented with both the destination key (as a ) and the source key (as a  ( destination))patchTest whether a  satisfies its invariants.patchEnumerate what reasons a + doesn't satisfy its invariants, returning [] if it's valid.patchMake a  k v7 which has the effect of inserting or updating a value v a to the given key k a, like .patchMake a  k v= which has the effect of moving the value from the first key k a to the second key k a, equivalent to:   src (maybe dmap ( dst) (DMap.lookup src dmap)) patchMake a  k vI which has the effect of swapping two keys in the mapping, equivalent to: j let aMay = DMap.lookup a dmap bMay = DMap.lookup b dmap in maybe id (DMap.insert a) (bMay mplus- aMay) . maybe id (DMap.insert b) (aMay mplus3 bMay) . DMap.delete a . DMap.delete b $ dmap patchMake a  k vF which has the effect of deleting a key in the mapping, equivalent to .patch Extract the ) representing the patch changes from the .patchWrap a # representing patch changes into a ", without checking any invariants.Warning:B when using this function, you must ensure that the invariants of ) are preserved; they will not be checked.patchWrap a # representing patch changes into a = while checking invariants. If the invariants are satisfied, Right p is returned otherwise  Left errors.patchMap a natural transform v -> v'$ over the given patch, transforming  k v into  k v'.patchTraverse an effectful function forall a. v a -> m (v ' a)$ over the given patch, transforming  k v into m ( k v').patchMap an effectful function !forall a. k a -> v a -> m (v ' a)$ over the given patch, transforming  k v into m ( k v').patch Map a function which transforms  k v a into a  k v' a over a  k v a.patch+Map an effectful function which transforms  k v a into a f ( k v' a) over a  k v a.patch Weaken a  to a h by weakening the keys from k a to  k) and applying a given weakening function  v a -> v' to values.patchWeaken a  (Const2 k a) v to a h k v'(. Weaken is in scare quotes because the O has already disabled any dependency in the typing and all points are already a*, hence the function to map each value to v' is not higher rank.patch Strengthen a h k v into a 'PatchDMapWithMove ( k a); that is, turn a non-dependently-typed patch into a dependently typed one but which always has a constant key type represented by #. Apply the given function to each v to produce a v' a. Completemented by patchcGet the values that will be replaced, deleted, or moved if the given patch is applied to the given .patch6Apply the insertions, deletions, and moves to a given .patchHCompose patches having the same effect as applying the patches in turn: 1 (p <> q) == 1 p . 1 qpatchTest whether two  k v# contain the same patch operations.patchHCompose patches having the same effect as applying the patches in turn: 1 (p <> q) == 1 p . 1 q""This module defines the . class.NoneHVxpatchThe elements of an  0 can be considered as patches of their own type.patchAn  ! is one where (<>) is commutativepatchA  is a $ where every element has an inverse.../012456789ABCDENOPQRSTUVWhlqrs../012456789ABCDENOPQRSTUVWhlqrs       !"#$%&'()*+,-./0123456789::;<=>?@ABCDEFFGHIJKLMNOPQRRSTUVWXYZ?[\]^_`abcdeffghiijklmnopqrstuvwxyz{|}~^_`abcdeffghw}~$patch-0.0.0.1-HZPUg4I4EEXJWhogtjFpRmData.Functor.MiscData.Patch.ClassData.Patch.IntMapData.Patch.MapData.Patch.DMapData.Patch.MapWithMoveData.Patch.DMapWithMove Data.Patch ComposeMaybegetComposeMaybe EitherTagLeftTagRightTagWrapArgConst2unConst2 dmapToMap dmapToIntMap dmapToMapWith mapToDMapmapWithFunctorToDMapintMapWithFunctorToDMapweakenDMapWithmapKeyValuePairsMonotoniccombineDMapsWithKey dmapToThese eitherToDSum dsumToEither$fGComparekConst2 $fGEqkConst2$fGShowkConst2$fGCompareTYPEWrapArg$fGEqTYPEWrapArg$fGShowkEitherTag$fGComparekEitherTag$fGEqkEitherTag$fShowComposeMaybe$fEqComposeMaybe$fOrdComposeMaybe$fFunctorComposeMaybe$fOrdEitherTag $fEqEitherTag$fShowEitherTag $fReadWrapArg $fShowWrapArg $fOrdWrapArg $fEqWrapArg $fReadConst2 $fShowConst2 $fOrdConst2 $fEqConst2Patch PatchTargetapply applyAlwayscomposePatchFunctions$fPatchIdentity PatchIntMapmapIntMapPatchWithKeytraverseIntMapPatchWithKeypatchIntMapNewElementspatchIntMapNewElementsMap getDeletions$fSemigroupPatchIntMap$fPatchPatchIntMap$fFunctorPatchIntMap$fFoldablePatchIntMap$fTraversablePatchIntMap$fMonoidPatchIntMapPatchMap unPatchMappatchMapNewElementspatchMapNewElementsMap$fFunctorPatchMap$fMonoidPatchMap$fSemigroupPatchMap$fPatchPatchMap$fShowPatchMap$fReadPatchMap $fEqPatchMap $fOrdPatchMap PatchDMap unPatchDMap mapPatchDMaptraversePatchDMaptraversePatchDMapWithKeyweakenPatchDMapWithpatchDMapToPatchMapWithconst2PatchDMapWithconst2IntPatchDMapWith$fPatchPatchDMap$fMonoidPatchDMap$fSemigroupPatchDMapFixup Fixup_Delete Fixup_UpdateToFrom From_Insert From_Delete From_MoveNodeInfo_nodeInfo_from _nodeInfo_toPatchMapWithMovepatchMapWithMovepatchMapWithMoveInsertAllunPatchMapWithMove insertMapKey moveMapKey swapMapKey deleteMapKeyunsafePatchMapWithMovepatchMapWithMoveNewElementspatchMapWithMoveNewElementsMappatchThatSortsMapWithpatchThatChangesAndSortsMapWithpatchThatChangesMapnodeInfoMapFromnodeInfoMapMFrom nodeInfoSetTo$fMonoidPatchMapWithMove$fPatchPatchMapWithMove$fSemigroupPatchMapWithMove $fShowFrom $fReadFrom$fEqFrom $fOrdFrom $fFunctorFrom$fFoldableFrom$fTraversableFrom$fShowNodeInfo$fReadNodeInfo $fEqNodeInfo $fOrdNodeInfo$fFunctorNodeInfo$fFoldableNodeInfo$fTraversableNodeInfo$fShowPatchMapWithMove$fEqPatchMapWithMove$fOrdPatchMapWithMove$fFunctorPatchMapWithMove$fFoldablePatchMapWithMove$fTraversablePatchMapWithMovePair1PatchDMapWithMovevalidPatchDMapWithMove$validationErrorsForPatchDMapWithMove insertDMapKey moveDMapKey swapDMapKey deleteDMapKeyunPatchDMapWithMoveunsafePatchDMapWithMovepatchDMapWithMovemapPatchDMapWithMovetraversePatchDMapWithMove traversePatchDMapWithMoveWithKeynodeInfoMapFromMweakenPatchDMapWithMoveWith'patchDMapWithMoveToPatchMapWithMoveWithconst2PatchDMapWithMoveWithgetDeletionsAndMoves$fPatchPatchDMapWithMove$fMonoidPatchDMapWithMove$fEqPatchDMapWithMove$fSemigroupPatchDMapWithMove AdditivePatchunAdditivePatchAdditiveGroupnegateG~~$fGroupMonoidalMap$fAdditiveMonoidalMap$fPatchAdditivePatchbase Data.EitherEither,dependent-sum-0.6.2.0-8eCavzJlbfk5G2Wbr3BDQiData.Dependent.SumDSum(dependent-map-0.3-Kb3JxJ5UnCT9QckOXmN6iIData.Dependent.Map.InternalDMapcontainers-0.6.0.1Data.Map.InternalMapData.IntMap.InternalIntMapGHC.BaseFunctor Semigroup GHC.MaybeNothingData.Functor.IdentityIdentityJustfmapinsertdelete ApplicativeMonadData.Dependent.Map Data.SomeSomeMonoid