h-dJ[[      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                            0.0.8.4 #Misc utilities relating to functor. Safe-Inferred+,29:< 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 . Tag type for  to use it as a . 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. 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 Extract the value from a Const2  Convert a  to a regular   Convert a  to an   Convert a  to a regular 6, applying the given function to remove the wrapping Convert a regular  to a Convert a regular ;, where the values are already wrapped in a functor, to a Convert a regular ;, where the values are already wrapped in a functor, to a  Convert a  to a regular  by forgetting the types associated with the keys, using a function to remove the wrapping "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. Union two s of different types, yielding another type. Each key that is present in either input map will be present in the output.Extract the values of a  of s.Convert  to a  . Inverse of .Convert  to  . Inverse of .     ( " & . $  " = !"8#($'%)&9':(8)6*0+1,/--This module provides a class to decide whether a monoid element is the identity.None29T.A . 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.0././0#1 62 -3 $4 /5 *6 &7 8 9 : ; < = "> 6? 6@ !A "B 1C 5D:>E6 6F3 3G2 2H1 1I0 0!JKLMN>O>PQRS>The module provides the T class. Safe-Inferred 2TA 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.VApply the patch p a to the value a#. If no change is needed, return .WApply a T/; if it does nothing, return the original valueXLike , 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 .[ can be used as a T that does nothing.\ can be used as a T% that always fully replaces the valueWXTUVTUVWXY4 4,Z0 0([, ,-\' 'Module containing ], a T for .None 29<=>)]T 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.ia <> 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.jMap a function  Int -> a -> b over all as in the given ] a. (that is, all inserts/updates), producing a  PatchIntMap b.kMap an effectful function Int -> a -> f b over all as in the given ] a. (that is, all inserts/updates), producing a f (PatchIntMap b).l Extract all a s inserted/updated by the given ] a.mConvert the given ] a into an  a2 with all the inserts/updates in the given patch.nSubset the given  a> to contain only the keys that would be deleted by the given ] a.r-Apply the insertions or deletions to a given .njlmk]^_]^_jklmn`&&a&&b&&c&&!d''e''f'!',g((h(($i..,o< <.p; ;+q: :*r3 3s00t00A basic T on None 29<=>uA 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 sx-Apply the insertions or deletions to a given .ya <> 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. The empty u$ contains no insertions or deletionsping a u will alter all of the values it will insert. Deletions are unaffected.7Returns all the new elements that will be added to the 7Returns all the new elements that will be added to the uvwuvwx; ;'y5 5+z''{''|''}''!~((((#))001..' - * )A basic T on None  29 A 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.Map a function  v a -> v' a( over any inserts/updates in the given  k v to produce a  k v'.Map an effectful function v a -> f (v' a)( over any inserts/updates in the given  k v to produce a  k v'.Map an effectful function k a -> v a -> f (v' a)( over any inserts/updates in the given  k v to produce a  k v'. Weaken a  k v to a u (Some k) v' using a function  v a -> v'- to weaken each value contained in the patch.Convert a weak  ( k a) v where the a is known by way of the Const2 into a u k v' using a rank 1 function  v a -> v'. Convert a u k v into a  ( k a) v' using a function  v -> v' a. Convert a ] v into a  ( Int a) v' using a function  v -> v' a.Get the values that will be replaced or deleted if the given patch is applied to the given .-Apply the insertions or deletions to a given .  2 2-. .6++7)): An advanced T on None 29hHelper data structure used for composing patches using the monoid instance.6Describe 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.1Describe how a key's new value should be producedInsert the given value here,Delete the existing value, if any, from hereMove the value here from the given key, and apply the given patchHolds the information about each key: where its new value should come from, and where its old value should go toIf the old value is being kept (i.e. moved rather than deleted or replaced), where is it going?+Where do we get the new value for this key?Patch 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.+Extract the internal representation of the  Create a , validating it Create a & that inserts everything in the given Make a  k p8 which has the effect of inserting or replacing a value v at the given key k, like .Make 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)) Make 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 Make a  k v which has the effect of deleting a key in the mapping, equivalent to .Wrap 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.7Returns all the new elements that will be added to the  Return a  k v- with all the inserts/updates from the given  k v. 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. 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. Create a  that, if applied to the first $ provided, will produce the second 4. Note: this will never produce a patch on a value. 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. Change the  value of a  Change the  value of a  , using a  (or , #, etc.) action to get the new valueSet the  field of a  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.Compose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q6Apply the insertions, deletions, and moves to a given Compose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q!! 4  7''An intermediate T on None )29<=> A1Describe how a key's new value should be producedHolds the information about each key: where its new value should come from, and where its old value should go toPatch 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.=Extract the underlying 'PatchMapWithPatchingMove k (Proxy v)'&Move the value here from the given key,Delete the existing value, if any, from hereInsert the given value here"Extract the representation of the  as a map of . Create a , validating it Create a & that inserts everything in the given Make a  k v7 which has the effect of inserting or updating a value v to the given key k, like .Make 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)) Make 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 Make a  k v which has the effect of deleting a key in the mapping, equivalent to .Wrap 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.7Returns all the new elements that will be added to the . Return a  k v- with all the inserts/updates from the given  k v. 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. 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. Create a  that, if applied to the first $ provided, will produce the second .Like  Change the  value of a  Change the  value of a  , using a  (or , #, etc.) action to get the new valueSet the  field of a Like 6Apply the insertions, deletions, and moves to a given Compose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q#( / 5 2 1 * ' & "  !74:: A more advanced T for .None +,2!Helper data structure used for composing patches using the monoid instance.$Higher kinded 2-tuple, identical to Data.Functor.Product from base D 4.9"Type alias for the "to" part of a .  ( k)) means the key is moving to another key, ComposeMaybe Nothing for any other operation.Structure 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). aMay) . maybe id (DMap.insert b) (aMay <> bMay) . DMap.delete a . DMap.delete b $ dmap Make a  k v which has the effect of deleting a key in the mapping, equivalent to  . Extract the ) representing the patch changes from the .Wrap 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.Wrap a # representing patch changes into a = while checking invariants. If the invariants are satisfied, Right p is returned otherwise  Left errors.Map a natural transform v -> v'$ over the given patch, transforming  k v into  k v'.Traverse an effectful function forall a. v a -> m (v ' a)$ over the given patch, transforming  k v into m ( k v').Map an effectful function !forall a. k a -> v a -> m (v ' a)$ over the given patch, transforming  k v into m ( k v'). Map a function which transforms  k v a into a  k v' a over a  k v a.+Map an effectful function which transforms  k v a into a f ( k v' a) over a  k v a. Weaken a  to a  by weakening the keys from k a to  k) and applying a given weakening function  v a -> v' to values.Weaken 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. 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 Get the values that will be replaced, deleted, or moved if the given patch is applied to the given .6Apply the insertions, deletions, and moves to a given .Compose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W qTest whether two  k v# contain the same patch operations.Compose patches having the same effect as applying the patches in turn: W (p <> q) == W p . W q"" ! 5! 6! !8 8>! 9! ! !!! A deprecated module containing a deprecated alias to the class for commutative semigroups Safe-Inferred12&Deprecated alias for  This module defines the ( class, and reexports the other modules.None  29 The elements of an  0 can be considered as patches of their own type.A  is a $ where every element has an inverse. Functions lift groups pointwise.Trivial group, Functor style!Product of groups, Functor style.6Product group. A Pair of groups gives rise to a groupTrivial group.3Identity lifts groups pointwise (at only one point)"Const lifts groups into a functor."0WXjlmkTUVU]^_uvw%jlmk]^_ # ## # ;# 0# ,# #? ?5#; ;2#0#/ A T combinator type for patching or replacing with a separate new value.None 29?patch&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. Traverse a  with a function for each case To apply a  p apply the the underlying p or substitute the replacement U p.$ $ ,$; ;1$( ($--$,,$++$**%%%&'()**++,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~~~                                                    "                         patch-0.0.8.4-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.Coercecoercesrc/Data/Functor/Misc.hs $dmisEmpty!src/Data/Monoid/DecidablyEmpty.hssrc/Data/Patch/Class.hssrc/Data/Patch/IntMap.hssrc/Data/Patch/Map.hssrc/Data/Patch/DMap.hsMapinsertdelete%src/Data/Patch/MapWithPatchingMove.hsData.Bitraversable bitraversesrc/Data/Patch/MapWithMove.hsDMapsrc/Data/Patch/DMapWithMove.hs$dm~~src/Data/Patch.hs$src/Data/Patch/PatchOrReplacement.hs 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$fDecidablyEmptyTuple5$fDecidablyEmptyTuple4$fDecidablyEmptyTuple3$fDecidablyEmptyTuple2$fDecidablyEmpty:*:$fDecidablyEmptyU1$fDecidablyEmptyProxy$fDecidablyEmptyMin$fDecidablyEmptyMax$fDecidablyEmptyLast$fDecidablyEmptyFirst$fDecidablyEmptySum$fDecidablyEmptyProduct$fDecidablyEmptyMaybe$fDecidablyEmptyList$fDecidablyEmptyAll$fDecidablyEmptyAny$fDecidablyEmptyUnit$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_to_nodeInfo_fromPatchMapWithPatchingMoveunPatchMapWithPatchingMovepatchMapWithPatchingMove!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:.: $fGroupTuple2 $fGroupUnit$fGroupMonoidalMap$fPatchAdditivePatch$fGroupIdentity $fGroupConstPatchOrReplacementPatchOrReplacement_PatchPatchOrReplacement_ReplacementtraversePatchOrReplacement$fSemigroupPatchOrReplacement$fMonoidPatchOrReplacement$fPatchPatchOrReplacement$fGenericPatchOrReplacement$fReadPatchOrReplacement$fShowPatchOrReplacement$fOrdPatchOrReplacement$fEqPatchOrReplacement_PatchOrReplacement_Patch_PatchOrReplacement_Replacement ghc-internalGHC.Internal.MaybeMaybeGHC.Internal.Data.EitherEitherdependent-sum-0.7.2.0-c21debc69da2457b06bf8f129ea36675e875a228a48b414fa3c7f7455ab1d93aData.Dependent.SumDSumdependent-map-0.4.0.0-859255f53588e22516946fb09a49aa7e15b5814d7cbd2fae46bc574329677aa8Data.Dependent.Map.Internalcontainers-0.7-inplaceData.Map.InternalData.IntMap.InternalIntMapGHC.Internal.BaseFunctormemptyghc-prim GHC.ClassesEq SemigroupNothing.GHC.Internal.Data.ProxyProxy"GHC.Internal.Data.Functor.IdentityIdentityJustfmap ApplicativeMonadsome-1.0.6-e85b1da84aa12c52dd34da2a4dc3a4b2e0702d0d3d63dbdc7bf295f148b35ddbData.Some.NewtypeSomecommutative-semigroups-0.2.0.1-4c6f6e240d822cefc798a428d5b7b4567075b77bc2b7daf91d54da0c5b0c2c3dData.Semigroup.Commutative CommutativeMonoid