h*bZ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                           0.0.8.2 #Misc utilities relating to functor. Safe-Inferred)*0679 patch We can't use   instead of , because that would make the f. parameter have a nominal type role. We need f1 to be representational so that we can use safe .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 k v v 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. Safe-Inferred06=.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 S class. Safe-Inferred0"SpatchA S: type represents a kind of change made to a datastructure.If an instance of S is also an instance of , it should obey the law that 5applyAlways (f <> g) == applyAlways f . applyAlways g.UpatchApply the patch p a to the value a#. If no change is needed, return .VpatchApply a S/; if it does nothing, return the original valueWpatchLike , 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 .Zpatch can be used as a S that does nothing.[patch can be used as a S% that always fully replaces the valueSUTVWSUTVWModule containing \, a S for . Safe-Inferred069:;\patchS 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.hpatcha <> 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.ipatchMap a function  Int -> a -> b over all as in the given \ a. (that is, all inserts/updates), producing a  PatchIntMap b.jpatchMap an effectful function Int -> a -> f b over all as in the given \ a. (that is, all inserts/updates), producing a f (PatchIntMap b).kpatch Extract all a s inserted/updated by the given \ a.lpatchConvert the given \ a into an  a2 with all the inserts/updates in the given patch.mpatchSubset the given  a> to contain only the keys that would be deleted by the given \ a.qpatch-Apply the insertions or deletions to a given .\^]ijklm\^]ijklmA basic S on  Safe-Inferred069:;dtpatchA 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 swpatch-Apply the insertions or deletions to a given .xpatcha <> 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 t$ contains no insertions or deletionspatchping a t will alter all of the values it will insert. Deletions are unaffected.patch7Returns all the new elements that will be added to the patch7Returns all the new elements that will be added to the tvutvuA basic S on  Safe-Inferred 06!" 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 t (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 t k v' using a rank 1 function  v a -> v'.patch Convert a t 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 S on  Safe-Inferred060patchHelper 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: V (p <> q) == V p . V qpatch6Apply the insertions, deletions, and moves to a given patchCompose patches having the same effect as applying the patches in turn: V (p <> q) == V p . V q!!An intermediate S on  Safe-Inferred(069:;=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 .patchLike 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 patchLike patch6Apply the insertions, deletions, and moves to a given patchCompose patches having the same effect as applying the patches in turn: V (p <> q) == V p . V q#( A more advanced S for . Safe-Inferred)*0S!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: V (p <> q) == V p . V qpatchTest whether two  k v# contain the same patch operations.patchCompose patches having the same effect as applying the patches in turn: V (p <> q) == V p . V q"" A deprecated module containing a deprecated alias to the class for commutative semigroups Safe-Inferred/0TpatchDeprecated alias for  This module defines the ( class, and reexports the other modules. Safe-Inferred 06W] 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./STU\]^TtuvVWijkl.STU\]^tuvVWijkl A S combinator type for patching or replacing with a separate new value. Safe-Inferred06<Zpatch&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.  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.patch Traverse a  with a function for each casepatch To apply a  p apply the the underlying p or substitute the replacement T p. !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmmnopqrstuvwxyz{|}~}                                                                           patch-0.0.8.2-inplaceData.Functor.MiscData.Monoid.DecidablyEmptyData.Patch.ClassData.Patch.IntMapData.Patch.MapData.Patch.DMapData.Patch.MapWithPatchingMoveData.Patch.MapWithMoveData.Patch.DMapWithMoveData.Semigroup.Additive Data.PatchData.Patch.PatchOrReplacementpatchData.Functor.ComposeCompose Data.CoercecoerceData.Bitraversable bitraverse 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$fDecidablyEmptyLast$fDecidablyEmptyFirst$fDecidablyEmptySum$fDecidablyEmptyProduct$fDecidablyEmptyMaybe$fDecidablyEmptyList$fDecidablyEmptyAll$fDecidablyEmptyAny$fDecidablyEmpty()$fDecidablyEmptyOrdering$fDecidablyEmpty:.:$fDecidablyEmptyK1$fDecidablyEmptyM1$fDecidablyEmptyRec1$fDecidablyEmptyPar1$fDecidablyEmptyDown$fDecidablyEmptyConst$fDecidablyEmptyWrappedMonoid$fDecidablyEmptyIdentity$fDecidablyEmptyDualPatch PatchTargetapply applyAlwayscomposePatchFunctions$fPatchProduct $fPatchSum $fPatchProxy$fPatchIdentity PatchIntMap unPatchIntMap$fShowPatchIntMap$fReadPatchIntMap$fEqPatchIntMap$fOrdPatchIntMap$fFunctorPatchIntMap$fFoldablePatchIntMap$fTraversablePatchIntMap$fMonoidPatchIntMap$fDecidablyEmptyPatchIntMap$fSemigroupPatchIntMapmapIntMapPatchWithKeytraverseIntMapPatchWithKeypatchIntMapNewElementspatchIntMapNewElementsMap getDeletions$$fTraversableWithIndexIntPatchIntMap!$fFoldableWithIndexIntPatchIntMap $fFunctorWithIndexIntPatchIntMap$fPatchPatchIntMap$fWrappedPatchIntMap$fRewrappedPatchIntMaptPatchMap unPatchMap$fPatchPatchMap$fSemigroupPatchMap$fShowPatchMap$fReadPatchMap $fEqPatchMap $fOrdPatchMap$fFoldablePatchMap$fTraversablePatchMap$fDecidablyEmptyPatchMap$fMonoidPatchMap$fFunctorPatchMappatchMapNewElementspatchMapNewElementsMap$fTraversableWithIndexkPatchMap$fFoldableWithIndexkPatchMap$fFunctorWithIndexkPatchMap$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 patchMapKey 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 AdditivePatchunAdditivePatchGroupnegateG~~ $fGroupFUN $fGroupProxy $fGroup:*: $fGroup:.: $fGroup(,) $fGroup()$fGroupMonoidalMap$fPatchAdditivePatch$fGroupIdentity $fGroupConstPatchOrReplacementPatchOrReplacement_PatchPatchOrReplacement_ReplacementtraversePatchOrReplacement$fSemigroupPatchOrReplacement$fMonoidPatchOrReplacement$fPatchPatchOrReplacement$fGenericPatchOrReplacement$fReadPatchOrReplacement$fShowPatchOrReplacement$fOrdPatchOrReplacement$fEqPatchOrReplacement_PatchOrReplacement_Patch_PatchOrReplacement_Replacementbase GHC.MaybeMaybe Data.EitherEither,dependent-sum-0.7.2.0-BUmkNYebL8kK7r5rz56t27Data.Dependent.SumDSum,dependent-map-0.4.0.0-8CFAuxkUpXY6pySjlcFtOcData.Dependent.Map.InternalDMapcontainers-0.6.7Data.Map.InternalMapData.IntMap.InternalIntMapGHC.BaseFunctormemptyghc-prim GHC.ClassesEq SemigroupNothing. Data.ProxyProxyData.Functor.IdentityIdentityJustfmapinsertdelete ApplicativeMonadData.Dependent.Map!some-1.0.5-GHpChqUGtWDKFB9o1ve35CData.Some.NewtypeSome5commutative-semigroups-0.1.0.1-9NWoqLSYvhn2d3zjfXiCgUData.Semigroup.Commutative CommutativeMonoid