úÎ!å¼ÙÈÆ      !"#$%&'()*+,-./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 value2patch¸Like '(.)', 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 ÉFpatchÐping 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_ŠM\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 Ó, aMay) . maybe id (Map.insert b) (aMay Ó0 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.9–patch"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 a™patchDelete the existing keyšpatch"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 qµpatchTest 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.NoneHVØT¼patchThe elements of an ¿ Ì0 can be considered as patches of their own type.¿patchAn ¿ Ì! is one where (<>) is commutativeÀpatchA À is a Ù$ where every element has an inverse.../012456789ABCDENOPQRSTUVWhlqrsŸ§¨ª¬¯°±¼½¾¿ÀÂÁ.¼½¾¿ÀÂÁ./012456789ABCDENOPQRSTUVWhlqrsŸ§¨ª¬¯°±Ú       !"#$%&'()*+,-./0123456789::;<=>?@ABCDEFFGHIJKLMNOPQRRSTUVWXYZ?[\]^_`abcdeffghiijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ^_`‘‘abcdeffgh’’“”•–—˜™š›œžwŸ ¡¢£¤¥¦§}~€„¨¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼º½¾±¿À±¿Á±ÂñÄűÂƱ¿Çº»Èº»É±¿Ê±¿˱¿Ì·ÍÈ·ÍÉ´Îϱ¿ÐÑ$patch-0.0.0.0-JtduIV1VcmXE2jeXV7zmzsData.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.IdentityIdentityJustfmapinsertdeletemplus ApplicativeMonadData.Dependent.Map Data.SomeSomeMonoid