h$`X      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                     #Misc utilities relating to functor. Safe-Inferred'(.235>? 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  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 s 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 .  This module provides a class to decide whether a monoid element is the identity.None.29.patchA . is one where it can be computed whether or not an arbitrary value is . By using this class rather than 5, we avoid unnecessary constraining the contents of s. This makes it possible to efficiently combine and/or nest patch maps with /-lacking values (e.g. functions) at the leaves.././The module provides the T class. Safe-Inferred.TpatchA T: type represents a kind of change made to a datastructure.If an instance of T is also an instance of , 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 .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 .Ypatch can be used as a T that does nothing.Zpatch can be used as a T% that always fully replaces the valueTVUWXTVUWXModule containing [, a T for .None.2567>[patchT for  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 a. 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  a2 with all the inserts/updates in the given patch.lpatchSubset the given  a> to contain only the keys that would be deleted by the given [ a.ppatch-Apply the insertions or deletions to a given .[\]hijkl[\]hijklA basic T on None.2567>spatchA set of changes to a . Any element may be inserted/updated or deleted. Insertions are represented as values wrapped in &, while deletions are represented as svpatch7Returns all the new elements that will be added to the wpatch7Returns all the new elements that will be added to the {patch-Apply the insertions or deletions to a given .|patcha <> b will apply the changes of b and then apply the changes of a. 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 deletionspatchping a s will alter all of the values it will insert. Deletions are unaffected.stuvwstuvwA basic T on None .2 patchA set of changes to a . 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.patchGet the values that will be replaced or deleted if the given patch is applied to the given .patch-Apply the insertions or deletions to a given .   An advanced T on None.2>?0npatchHelper data structure used for composing patches using the monoid instance.patch6Describe where a key's old value will go. If this is , 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 producedpatchInsert the given value herepatch,Delete the existing value, if any, from herepatchMove the value here from the given key, and apply the given patchpatchHolds 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?patchIf the old value is being kept (i.e. moved rather than deleted or replaced), where is it going?patchPatch 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 k1, and vice versa. There should never be any unpaired From/To keys.patch+Extract the internal representation of the patch Create a , validating itpatch Create a & that inserts everything in the given patchMake a  k p8 which has the effect of inserting or replacing a value v at the given key k, like .patchMake a  k p= 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)) patchMake a  k p which has the effect of swapping two keys in the mapping, equivalent to:  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 <> bMay) . Map.delete a . Map.delete b $ map patchMake a  k v which has the effect of deleting a key in the mapping, equivalent to .patchWrap a  k (NodeInfo k v)# representing patch changes into a  k v", without checking any invariants.Warning: 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 patch Return a  k v- with all the inserts/updates from the given  k v.patch Create a  that, if applied to the given , will sort its values using the given ordering function. The set keys of the  is not changed.patch Create a  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.patch Create a  that, if applied to the first $ provided, will produce the second 4. Note: this will never produce a patch on a value.patch Traverse the  over the key, patch, and patch target. Because of the type families here, this doesn't it any bi- or tri-traversal class.patch Change the  value of a patch Change the  value of a  , using a  (or , #, etc.) action to get the new valuepatchSet the  field of a patch Traverse the  over the key, patch, and patch target. Because of the type families here, this doesn't it any bi- or tri-traversal class.patchCompose 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 patchCompose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q  An intermediate T on None&.2567>?=patch1Describe how a key's new value should be producedpatchHolds the information about each key: where its new value should come from, and where its old value should go topatchPatch 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 k1, and vice versa. There should never be any unpaired From/To keys.patch=Extract the underlying 'PatchMapWithPatchingMove k (Proxy v)'patch&Move the value here from the given keypatch,Delete the existing value, if any, from herepatchInsert the given value herepatch"Extract the representation of the  as a map of .patch Create a , validating itpatch Create a & that inserts everything in the given patchMake a  k v7 which has the effect of inserting or updating a value v to the given key k, like .patchMake a  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)) patchMake a  k v which has the effect of swapping two keys in the mapping, equivalent to:  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 <> bMay) . Map.delete a . Map.delete b $ map patchMake a  k v which has the effect of deleting a key in the mapping, equivalent to .patchWrap a  k (NodeInfo k v)# representing patch changes into a  k v", without checking any invariants.Warning: 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 .patch Return a  k v- with all the inserts/updates from the given  k v.patch Create a  that, if applied to the given , will sort its values using the given ordering function. The set keys of the  is not changed.patch Create a  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.patch Create a  that, if applied to the first $ provided, will produce the second .patch Change the  value of a patch Change the  value of a  , using a  (or , #, etc.) action to get the new valuepatchSet the  field of a patch6Apply the insertions, deletions, and moves to a given patchCompose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q#( A more advanced T for .None'(.>?R!patchHelper data structure used for composing patches using the monoid instance.patch$Higher kinded 2-tuple, identical to Data.Functor.Product from base D 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.patchStructure 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 aMay) . maybe id (DMap.insert b) (aMay <> bMay) . DMap.delete a . DMap.delete b $ dmap patchMake a  k v 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: 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  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  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 patchGet 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 .patchCompose 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.patchCompose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q"" "A class for commutative semigroups Safe-Inferred.UpatchAn  ! is one where (<>) is commutativepatch-Functions lift additive semigroups pointwise.patchIdentity lifts additive semigroups pointwise (at only one point)patch/Const lifts additive semigroups into a functor.patch)Trivial additive semigroup, Functor stylepatch.Product of additive semigroups, Functor style.patchProduct additive semigroup. A Pair of additive semigroups gives rise to a additive semigrouppatchTrivial additive semigroup. This module defines the ( class, and reexports the other modules.None .2XA patchThe elements of an  0 can be considered as patches of their own type.patchA  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 grouppatchTrivial group.patch3Identity lifts groups pointwise (at only one point)patch"Const lifts groups into a functor.0TUVUWX[\]hijkstuvw/TUVWX[\]hijkstuvw    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcddefghijklmnopqrstuvwxyz{{|}~t                                                                     $patch-0.0.5.1-L3pZnmMeKU34MFZsdaIs5zData.Functor.MiscData.Monoid.DecidablyEmptyData.Patch.ClassData.Patch.IntMapData.Patch.MapData.Patch.DMapData.Patch.MapWithPatchingMoveData.Patch.MapWithMoveData.Patch.DMapWithMoveData.Semigroup.Additive 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 $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$fSemigroupPatchDMapFixup Fixup_Delete Fixup_UpdateToFrom From_Insert From_Delete From_MoveNodeInfo_nodeInfo_from _nodeInfo_toPatchMapWithPatchingMoveunPatchMapWithPatchingMovepatchMapWithPatchingMove!patchMapWithPatchingMoveInsertAll insertMapKey moveMapKey swapMapKey deleteMapKeyunsafePatchMapWithPatchingMove#patchMapWithPatchingMoveNewElements&patchMapWithPatchingMoveNewElementsMappatchThatSortsMapWithpatchThatChangesAndSortsMapWithpatchThatChangesMapbitraverseNodeInfonodeInfoMapFromnodeInfoMapMFrom nodeInfoSetTobitraverseFrom $fMonoidPatchMapWithPatchingMove$fPatchPatchMapWithPatchingMove#$fSemigroupPatchMapWithPatchingMove $fOrdFrom$fEqFrom $fReadFrom $fShowFrom $fOrdNodeInfo $fEqNodeInfo$fReadNodeInfo$fShowNodeInfo($fDecidablyEmptyPatchMapWithPatchingMove$fOrdPatchMapWithPatchingMove$fEqPatchMapWithPatchingMove$fReadPatchMapWithPatchingMove$fShowPatchMapWithPatchingMove!$fWrappedPatchMapWithPatchingMove$$fRewrappedPatchMapWithPatchingMovetFrom'unFrom' NodeInfo' unNodeInfo'PatchMapWithMovePatchMapWithMove'unPatchMapWithMove'unPatchMapWithMovepatchMapWithMovepatchMapWithMoveInsertAllunsafePatchMapWithMovepatchMapWithMoveNewElementspatchMapWithMoveNewElementsMap$fPatchPatchMapWithMove'$fTraversableWithIndexkPatchMapWithMove$$fFoldableWithIndexkPatchMapWithMove#$fFunctorWithIndexkPatchMapWithMove$fTraversablePatchMapWithMove$fFoldablePatchMapWithMove$fFunctorPatchMapWithMove$fTraversableNodeInfo$fFoldableNodeInfo$fFunctorNodeInfo$fShowPatchMapWithMove$fReadPatchMapWithMove$fEqPatchMapWithMove$fOrdPatchMapWithMove$fSemigroupPatchMapWithMove$fMonoidPatchMapWithMove$fWrappedPatchMapWithMove$fRewrappedPatchMapWithMovet$fWrappedNodeInfo$fRewrappedNodeInfot $fWrappedFrom$fRewrappedFromtPair1PatchDMapWithMovevalidPatchDMapWithMove$validationErrorsForPatchDMapWithMove insertDMapKey moveDMapKey swapDMapKey deleteDMapKeyunPatchDMapWithMoveunsafePatchDMapWithMovepatchDMapWithMovemapPatchDMapWithMovetraversePatchDMapWithMove traversePatchDMapWithMoveWithKeynodeInfoMapFromMweakenPatchDMapWithMoveWith'patchDMapWithMoveToPatchMapWithMoveWithconst2PatchDMapWithMoveWithgetDeletionsAndMoves$fPatchPatchDMapWithMove$fMonoidPatchDMapWithMove$fEqPatchDMapWithMove!$fDecidablyEmptyPatchDMapWithMove$fSemigroupPatchDMapWithMoveAdditive $fAdditive->$fAdditiveIdentity$fAdditiveConst$fAdditiveProxy $fAdditive:*: $fAdditive:.: $fAdditive(,) $fAdditive() AdditivePatchunAdditivePatchGroupnegateG~~ $fGroup-> $fGroupProxy $fGroup:*: $fGroup:.: $fGroup(,) $fGroup()$fGroupMonoidalMap$fPatchAdditivePatch$fGroupIdentity $fGroupConstbase Data.EitherEither,dependent-sum-0.7.1.0-7zkm7bfAkjD1MeErzCq7w9Data.Dependent.SumDSum,dependent-map-0.4.0.0-LN4dlnpdhCMAZTm2dBTzpzData.Dependent.Map.InternalDMapcontainers-0.6.2.1Data.Map.InternalMapData.IntMap.InternalIntMapGHC.BaseFunctormemptyghc-prim GHC.ClassesEq Semigroup GHC.MaybeNothing. Data.ProxyProxyData.Functor.IdentityIdentityJustfmapinsertdelete ApplicativeMonadData.Dependent.Map!some-1.0.3-EkurWqTp0mZLHswRnbJS58Data.Some.NewtypeSomeMonoid