!0J      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I Safe&'-124=>?@AHSX_g*patch 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 J to use it as a K.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 L to a regular M patch Convert a L to an N patch Convert a L to a regular M6, applying the given function to remove the wrapping OpatchConvert a regular M to a LpatchConvert a regular M;, where the values are already wrapped in a functor, to a LpatchConvert a regular N;, where the values are already wrapped in a functor, to a Lpatch Convert a L to a regular M\ by forgetting the types associated with the keys, using a function to remove the wrapping Opatch"Map over all key/value pairs in a L, potentially altering the key as well as the value. The provided function MUST preserve the ordering of the keys, or the resulting L will be malformed.patch Union two Lzs 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 L of s.patchConvert J to a K . Inverse of .patchConvert K to J . Inverse of .  None18MUV/.patchA .G is one where it can be computed whether or not an arbitrary value is P. By using this class rather than Q5, we avoid unnecessary constraining the contents of ONs. This makes it possible to efficiently combine and/or nest patch maps with Q/-lacking values (e.g. functions) at the leaves.././SafeHV:TpatchA T: type represents a kind of change made to a datastructure.If an instance of T is also an instance of R, it should obey the law that 5applyAlways (f <> g) == applyAlways f . applyAlways g.VpatchApply the patch p a to the value a#. If no change is needed, return S.WpatchApply a T/; if it does nothing, return the original valueXpatchLike '(.)', 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 '(.)'.YpatchT can be used as a T that does nothing.ZpatchU can be used as a T% that always fully replaces the valueTVUWXTVUWXNone1456=?@AHMVJW[patchT for Nu 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.gpatcha <> 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.hpatchMap a function  Int -> a -> b over all as in the given [ a. (that is, all inserts/updates), producing a  PatchIntMap b.ipatchMap an effectful function Int -> a -> f b over all as in the given [ a. (that is, all inserts/updates), producing a f (PatchIntMap b).jpatch Extract all a s inserted/updated by the given [ a.kpatchConvert the given [ a into an N a2 with all the inserts/updates in the given patch.lpatchSubset the given N a> to contain only the keys that would be deleted by the given [ a.ppatch-Apply the insertions or deletions to a given N.[\]hijkl[\]hijklNone1456=?@AHMV_UspatchA set of changes to a Me. Any element may be inserted/updated or deleted. Insertions are represented as values wrapped in V&, while deletions are represented as Ssvpatch7Returns all the new elements that will be added to the Mwpatch7Returns all the new elements that will be added to the M{patch-Apply the insertions or deletions to a given M.|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 The empty s$ contains no insertions or deletionspatchWping a sH will alter all of the values it will insert. Deletions are unaffected.stuvwstuvwNone -1HMSVX_g patchA set of changes to a LR. Any element may be inserted/updated or deleted. Insertions are represented as  (Just value)&, while deletions are represented as  Nothing.patchMap a function  v a -> v' a( over any inserts/updates in the given  k v to produce a  k v'.patchMap an effectful function v a -> f (v' a)( over any inserts/updates in the given  k v to produce a  k v'.patchMap an effectful function k a -> v a -> f (v' a)( over any inserts/updates in the given  k v to produce a  k v'.patch Weaken a  k v to a s (Some k) v' using a function  v a -> v'- to weaken each value contained in the patch.patchConvert a weak  ( k a) v where the a is known by way of the Const2 into a s k v' using a rank 1 function  v a -> v'.patch Convert a s k v into a  ( k a) v' using a function  v -> v' a.patch Convert a [ v into a  ( Int a) v' using a function  v -> v' a.patch[Get the values that will be replaced or deleted if the given patch is applied to the given L.patch-Apply the insertions or deletions to a given L. None456=>?@AHQVX_kpatch6Describe where a key's old value will go. If this is VQ, that means the key's old value will be moved to the given other key; if it is S!, that means it will be deleted.patch1Describe how a key's new value should be producedpatchInsert the given value herepatch,Delete the existing value, if any, from herepatch&Move the value here from the given keypatchqHolds the information about each key: where its new value should come from, and where its old value should go topatch+Where do we get the new value for this key?patch`If the old value is being kept (i.e. moved rather than deleted or replaced), where is it going?patchEPatch a Map 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.patch+Extract the internal representation of the patchKHelper data structure used for composing patches using the monoid instance.patch Create a , validating itpatch Create a & that inserts everything in the given MpatchMake a  k v7 which has the effect of inserting or updating a value v to the given key k, like X.patchMake a  k v= which has the effect of moving the value from the first key k to the second key k, equivalent to:  Y src (maybe map (X dst) (Map.lookup src map)) patchMake a  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 patchMake a  k vF which has the effect of deleting a key in the mapping, equivalent to Y.patchWrap a M k (NodeInfo k v)# representing patch changes into a  k v", without checking any invariants.Warning:B when using this function, you must ensure that the invariants of ) are preserved; they will not be checked.patch7Returns all the new elements that will be added to the M.patch Return a M k v- with all the inserts/updates from the given  k v.patch Create a  that, if applied to the given MP, will sort its values using the given ordering function. The set keys of the M is not changed.patch Create a  that, if applied to the first M provided, will produce a M$ with the same values as the second M> but with the values sorted with the given ordering function.patch Create a  that, if applied to the first M$ provided, will produce the second M.patch Change the  value of a patch Change the  value of a  , using a O (or Z, [#, etc.) action to get the new valuepatchSet the  field of a patchHCompose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W qpatch6Apply the insertions, deletions, and moves to a given MpatchHCompose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W qNone&'-=>?@AHQSVX_I!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 .  (V 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  , but for L. 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  (V 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 L) representing the patch changes from the .patchWrap a L# 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 L# 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  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  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  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 L.patch6Apply the insertions, deletions, and moves to a given L.patchHCompose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W qpatchTest whether two  k v# contain the same patch operations.patchHCompose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q"" This module defines the T class.None1HMUV patchThe elements of an  R0 can be considered as patches of their own type.patchAn  R! is one where (<>) is commutativepatchA  is a _$ where every element has an inverse.patch Functions lift groups pointwise.patchTrivial group, Functor stylepatch!Product of groups, Functor style. patch6Product group. A Pair of groups gives rise to a group patchTrivial group.patch3Ideitnty lifts groups pointwise (at only one point)patch"Const lifts groups into a functor./TUVWX[\]hijkstuvw/TUVWX[\]hijkstuvw None1=>?@AHMQVX_patchKHelper data structure used for composing patches using the monoid instance.patch6Describe where a key's old value will go. If this is VQ, that means the key's old value will be moved to the given other key; if it is S!, that means it will be deleted.patch1Describe how a key's new value should be producedpatchInsert the given value herepatch,Delete the existing value, if any, from herepatchAMove the value here from the given key, and apply the given patch patchqHolds the information about each key: where its new value should come from, and where its old value should go to"patch+Where do we get the new value for this key?#patch`If the old value is being kept (i.e. moved rather than deleted or replaced), where is it going?$patchEPatch a Map 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.&patch+Extract the internal representation of the $)patch Create a $, validating it*patch Create a $& that inserts everything in the given M+patchMake a $ k p8 which has the effect of inserting or replacing a value v at the given key k, like X.,patchMake a $ k p= which has the effect of moving the value from the first key k to the second key k, equivalent to:  Y src (maybe map (X dst) (Map.lookup src map)) -patchMake a $ k pI 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 .patchMake a $ k vG which has the effect of deleting a key in the mapping, equivalent to Y./patchWrap a M k (NodeInfo k v)# representing patch changes into a $ k v", without checking any invariants.Warning:B when using this function, you must ensure that the invariants of $) are preserved; they will not be checked.0patch7Returns all the new elements that will be added to the M1patch Return a M k v- with all the inserts/updates from the given $ k v.2patch Create a $ that, if applied to the given MP, will sort its values using the given ordering function. The set keys of the M is not changed.3patch Create a $ that, if applied to the first M provided, will produce a M$ with the same values as the second M> but with the values sorted with the given ordering function.4patch Create a $ that, if applied to the first M$ provided, will produce the second M.5patch Change the  value of a  6patch Change the  value of a   , using a O (or Z, [#, etc.) action to get the new value7patchSet the  field of a  8patchICompose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q9patch6Apply the insertions, deletions, and moves to a given M:patchICompose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q  !#"$%&'()*+,-./01234567 $%& !#"'()*+,-./01234567`     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abccdefghijklmnopqrstuvwxyzz{|}~s                                        !"#!$%&'&()*+&,-./012-3&4!"5!"6&7&89596:;&<=$patch-0.0.3.0-J7oG44l7vg8LWTNA9snVxAData.Functor.MiscData.Monoid.DecidablyEmptyData.Patch.ClassData.Patch.IntMapData.Patch.MapData.Patch.DMapData.Patch.MapWithMoveData.Patch.DMapWithMove Data.PatchData.Patch.MapWithPatchingMove 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 $fEqConst2DecidablyEmptyisEmpty$fDecidablyEmptyDMap$fDecidablyEmptySet$fDecidablyEmptySeq$fDecidablyEmptyMap$fDecidablyEmptyIntMap$fDecidablyEmptyIntSet$fDecidablyEmpty(,,,,)$fDecidablyEmpty(,,,)$fDecidablyEmpty(,,)$fDecidablyEmpty(,)$fDecidablyEmpty:*:$fDecidablyEmptyU1$fDecidablyEmptyProxy$fDecidablyEmptyMin$fDecidablyEmptyMax$fDecidablyEmptyOption$fDecidablyEmptyLast$fDecidablyEmptyFirst$fDecidablyEmptyMaybe$fDecidablyEmpty[]$fDecidablyEmptyAll$fDecidablyEmptyAny$fDecidablyEmpty()$fDecidablyEmptyOrdering$fDecidablyEmpty:.:$fDecidablyEmptyK1$fDecidablyEmptyM1$fDecidablyEmptyRec1$fDecidablyEmptyPar1$fDecidablyEmptyDown$fDecidablyEmptyConst$fDecidablyEmptyWrappedMonoid$fDecidablyEmptyIdentity$fDecidablyEmptyDual$fDecidablyEmptySum$fDecidablyEmptyProductPatch PatchTargetapply applyAlwayscomposePatchFunctions $fPatchProxy$fPatchIdentity PatchIntMap unPatchIntMap$fShowPatchIntMap$fReadPatchIntMap$fEqPatchIntMap$fOrdPatchIntMap$fFunctorPatchIntMap$fFoldablePatchIntMap$fTraversablePatchIntMap$fMonoidPatchIntMap$fDecidablyEmptyPatchIntMap$fSemigroupPatchIntMapmapIntMapPatchWithKeytraverseIntMapPatchWithKeypatchIntMapNewElementspatchIntMapNewElementsMap getDeletions$$fTraversableWithIndexIntPatchIntMap!$fFoldableWithIndexIntPatchIntMap $fFunctorWithIndexIntPatchIntMap$fPatchPatchIntMap$fWrappedPatchIntMap$fRewrappedPatchIntMaptPatchMap unPatchMappatchMapNewElementspatchMapNewElementsMap$fTraversableWithIndexkPatchMap$fFoldableWithIndexkPatchMap$fFunctorWithIndexkPatchMap$fPatchPatchMap$fSemigroupPatchMap$fShowPatchMap$fReadPatchMap $fEqPatchMap $fOrdPatchMap$fFoldablePatchMap$fTraversablePatchMap$fDecidablyEmptyPatchMap$fMonoidPatchMap$fFunctorPatchMap$fWrappedPatchMap$fRewrappedPatchMapt PatchDMap unPatchDMap mapPatchDMaptraversePatchDMaptraversePatchDMapWithKeyweakenPatchDMapWithpatchDMapToPatchMapWithconst2PatchDMapWithconst2IntPatchDMapWith$fPatchPatchDMap$fDecidablyEmptyPatchDMap$fMonoidPatchDMap$fSemigroupPatchDMapToFrom From_Insert From_Delete From_MoveNodeInfo_nodeInfo_from _nodeInfo_toPatchMapWithMoveunPatchMapWithMove $fShowFrom $fReadFrom$fEqFrom $fOrdFrom $fFunctorFrom$fFoldableFrom$fTraversableFrom$fShowNodeInfo$fReadNodeInfo $fEqNodeInfo $fOrdNodeInfo$fFunctorNodeInfo$fFoldableNodeInfo$fTraversableNodeInfo$fShowPatchMapWithMove$fReadPatchMapWithMove$fEqPatchMapWithMove$fOrdPatchMapWithMove$fFunctorPatchMapWithMove$fFoldablePatchMapWithMove$fTraversablePatchMapWithMoveFixup Fixup_Delete Fixup_UpdatepatchMapWithMovepatchMapWithMoveInsertAll insertMapKey moveMapKey swapMapKey deleteMapKeyunsafePatchMapWithMovepatchMapWithMoveNewElementspatchMapWithMoveNewElementsMappatchThatSortsMapWithpatchThatChangesAndSortsMapWithpatchThatChangesMapnodeInfoMapFromnodeInfoMapMFrom nodeInfoSetTo$fMonoidPatchMapWithMove$fPatchPatchMapWithMove'$fTraversableWithIndexkPatchMapWithMove$$fFoldableWithIndexkPatchMapWithMove#$fFunctorWithIndexkPatchMapWithMove$fWrappedPatchMapWithMove$fRewrappedPatchMapWithMovet$fSemigroupPatchMapWithMovePair1PatchDMapWithMovevalidPatchDMapWithMove$validationErrorsForPatchDMapWithMove insertDMapKey moveDMapKey swapDMapKey deleteDMapKeyunPatchDMapWithMoveunsafePatchDMapWithMovepatchDMapWithMovemapPatchDMapWithMovetraversePatchDMapWithMove traversePatchDMapWithMoveWithKeynodeInfoMapFromMweakenPatchDMapWithMoveWith'patchDMapWithMoveToPatchMapWithMoveWithconst2PatchDMapWithMoveWithgetDeletionsAndMoves$fPatchPatchDMapWithMove$fMonoidPatchDMapWithMove$fEqPatchDMapWithMove!$fDecidablyEmptyPatchDMapWithMove$fSemigroupPatchDMapWithMove AdditivePatchunAdditivePatchAdditiveGroupnegateG~~ $fGroup-> $fGroupProxy $fGroup:*: $fGroup:.: $fGroup(,) $fGroup()$fGroupMonoidalMap $fAdditive->$fAdditiveIdentity$fAdditiveConst$fAdditiveProxy $fAdditive:*: $fAdditive:.: $fAdditive(,) $fAdditive()$fAdditiveMonoidalMap$fPatchAdditivePatch$fGroupIdentity $fGroupConstPatchMapWithPatchingMoveunPatchMapWithPatchingMovebitraverseNodeInfobitraverseFrompatchMapWithPatchingMove!patchMapWithPatchingMoveInsertAllunsafePatchMapWithPatchingMove#patchMapWithPatchingMoveNewElements&patchMapWithPatchingMoveNewElementsMap $fMonoidPatchMapWithPatchingMove$fPatchPatchMapWithPatchingMove#$fSemigroupPatchMapWithPatchingMove($fDecidablyEmptyPatchMapWithPatchingMove$fOrdPatchMapWithPatchingMove$fEqPatchMapWithPatchingMove$fReadPatchMapWithPatchingMove$fShowPatchMapWithPatchingMove!$fWrappedPatchMapWithPatchingMove$$fRewrappedPatchMapWithPatchingMovetbase 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.BaseFunctormemptyghc-prim GHC.ClassesEq Semigroup GHC.MaybeNothing Data.ProxyProxyData.Functor.IdentityIdentityJustfmapinsertdelete ApplicativeMonadData.Dependent.Map Data.SomeSomeMonoid