Data.Patch.MapWithPatchingMove

Patches of this type can can insert, delete, and move values from one key to another, and move patches may also additionally patch the value being moved.

Documentation

newtype PatchMapWithPatchingMove k p

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.

Constructors

PatchMapWithPatchingMove

Fields

• unPatchMapWithPatchingMove :: Map k (NodeInfo k p)

  Extract the internal representation of the PatchMapWithPatchingMove

Instances

(Eq k, Eq p, Eq (PatchTarget p)) => Eq (PatchMapWithPatchingMove k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

(==) :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> Bool

(/=) :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> Bool

(Ord k, Ord p, Ord (PatchTarget p)) => Ord (PatchMapWithPatchingMove k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

compare :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> Ordering

(<) :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> Bool

(<=) :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> Bool

(>) :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> Bool

(>=) :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> Bool

max :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p

min :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p

(Ord k, Read k, Read p, Read (PatchTarget p)) => Read (PatchMapWithPatchingMove k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

readsPrec :: Int -> ReadS (PatchMapWithPatchingMove k p)

readList :: ReadS [PatchMapWithPatchingMove k p]

readPrec :: ReadPrec (PatchMapWithPatchingMove k p)

readListPrec :: ReadPrec [PatchMapWithPatchingMove k p]

(Show k, Show p, Show (PatchTarget p)) => Show (PatchMapWithPatchingMove k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

showsPrec :: Int -> PatchMapWithPatchingMove k p -> ShowS

show :: PatchMapWithPatchingMove k p -> String

showList :: [PatchMapWithPatchingMove k p] -> ShowS

(Ord k, DecidablyEmpty p, Patch p) => Semigroup (PatchMapWithPatchingMove k p)

Compose patches having the same effect as applying the patches in turn: applyAlways (p <> q) == applyAlways p . applyAlways q

Defined in Data.Patch.MapWithPatchingMove

Methods

(<>) :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p

sconcat :: NonEmpty (PatchMapWithPatchingMove k p) -> PatchMapWithPatchingMove k p

stimes :: Integral b => b -> PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p

(Ord k, DecidablyEmpty p, Patch p) => Monoid (PatchMapWithPatchingMove k p)

Compose patches having the same effect as applying the patches in turn: applyAlways (p <> q) == applyAlways p . applyAlways q

Defined in Data.Patch.MapWithPatchingMove

Methods

mempty :: PatchMapWithPatchingMove k p

mappend :: PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p -> PatchMapWithPatchingMove k p

mconcat :: [PatchMapWithPatchingMove k p] -> PatchMapWithPatchingMove k p

Wrapped (PatchMapWithPatchingMove k p)

Defined in Data.Patch.MapWithPatchingMove

Associated Types

type Unwrapped (PatchMapWithPatchingMove k p) :: Type

Methods

_Wrapped' :: Iso' (PatchMapWithPatchingMove k p) (Unwrapped (PatchMapWithPatchingMove k p))

(Ord k, DecidablyEmpty p, Patch p) => DecidablyEmpty (PatchMapWithPatchingMove k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

isEmpty :: PatchMapWithPatchingMove k p -> Bool

(Ord k, Patch p) => Patch (PatchMapWithPatchingMove k p)

Apply the insertions, deletions, and moves to a given Map

Defined in Data.Patch.MapWithPatchingMove

Associated Types

type PatchTarget (PatchMapWithPatchingMove k p) :: Type

Methods

apply :: PatchMapWithPatchingMove k p -> PatchTarget (PatchMapWithPatchingMove k p) -> Maybe (PatchTarget (PatchMapWithPatchingMove k p))

PatchMapWithPatchingMove k1 p1 ~ t => Rewrapped (PatchMapWithPatchingMove k2 p2) t

Defined in Data.Patch.MapWithPatchingMove

type Unwrapped (PatchMapWithPatchingMove k p)

Defined in Data.Patch.MapWithPatchingMove

type Unwrapped (PatchMapWithPatchingMove k p) = Map k (NodeInfo k p)

type PatchTarget (PatchMapWithPatchingMove k p)

Defined in Data.Patch.MapWithPatchingMove

type PatchTarget (PatchMapWithPatchingMove k p) = Map k (PatchTarget p)

patchMapWithPatchingMove :: Ord k => Map k (NodeInfo k p) -> Maybe (PatchMapWithPatchingMove k p)

Create a PatchMapWithPatchingMove, validating it

patchMapWithPatchingMoveInsertAll :: Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

Create a PatchMapWithPatchingMove that inserts everything in the given Map

insertMapKey :: k -> PatchTarget p -> PatchMapWithPatchingMove k p

Make a PatchMapWithPatchingMove k p which has the effect of inserting or replacing a value v at the given key k, like insert.

moveMapKey :: (DecidablyEmpty p, Patch p) => Ord k => k -> k -> PatchMapWithPatchingMove k p

Make a PatchMapWithPatchingMove k p which has the effect of moving the value from the first key k to the second key k, equivalent to:

    delete src (maybe map (insert dst) (Map.lookup src map))

patchMapKey :: DecidablyEmpty p => k -> p -> PatchMapWithPatchingMove k p

swapMapKey :: (DecidablyEmpty p, Patch p) => Ord k => k -> k -> PatchMapWithPatchingMove k p

Make a PatchMapWithPatchingMove 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

deleteMapKey :: k -> PatchMapWithPatchingMove k v

Make a PatchMapWithPatchingMove k v which has the effect of deleting a key in the mapping, equivalent to delete.

unsafePatchMapWithPatchingMove :: Map k (NodeInfo k p) -> PatchMapWithPatchingMove k p

Wrap a Map k (NodeInfo k v) representing patch changes into a PatchMapWithPatchingMove k v, without checking any invariants.

Warning: when using this function, you must ensure that the invariants of PatchMapWithPatchingMove are preserved; they will not be checked.

patchMapWithPatchingMoveNewElements :: PatchMapWithPatchingMove k p -> [PatchTarget p]

Returns all the new elements that will be added to the Map

patchMapWithPatchingMoveNewElementsMap :: PatchMapWithPatchingMove k p -> Map k (PatchTarget p)

Return a Map k v with all the inserts/updates from the given PatchMapWithPatchingMove k v.

patchThatSortsMapWith :: (Ord k, Monoid p) => (PatchTarget p -> PatchTarget p -> Ordering) -> Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

Create a PatchMapWithPatchingMove that, if applied to the given Map, will sort its values using the given ordering function. The set keys of the Map is not changed.

patchThatChangesAndSortsMapWith :: forall k p. (Ord k, Ord (PatchTarget p), Monoid p) => (PatchTarget p -> PatchTarget p -> Ordering) -> Map k (PatchTarget p) -> Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

Create a PatchMapWithPatchingMove that, if applied to the first Map provided, will produce a Map with the same values as the second Map but with the values sorted with the given ordering function.

patchThatChangesMap :: forall k p. (Ord k, Ord (PatchTarget p), Monoid p) => Map k (PatchTarget p) -> Map k (PatchTarget p) -> PatchMapWithPatchingMove k p

Create a PatchMapWithPatchingMove that, if applied to the first Map provided, will produce the second Map. Note: this will never produce a patch on a value.

Node Info

data NodeInfo k p

Holds the information about each key: where its new value should come from, and where its old value should go to

Constructors

NodeInfo

Fields

• _nodeInfo_from :: !(From k p)

  Where do we get the new value for this key?

• _nodeInfo_to :: !(To k)

  If the old value is being kept (i.e. moved rather than deleted or replaced), where is it going?

Instances

(Eq k, Eq p, Eq (PatchTarget p)) => Eq (NodeInfo k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

(==) :: NodeInfo k p -> NodeInfo k p -> Bool

(/=) :: NodeInfo k p -> NodeInfo k p -> Bool

(Ord k, Ord p, Ord (PatchTarget p)) => Ord (NodeInfo k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

compare :: NodeInfo k p -> NodeInfo k p -> Ordering

(<) :: NodeInfo k p -> NodeInfo k p -> Bool

(<=) :: NodeInfo k p -> NodeInfo k p -> Bool

(>) :: NodeInfo k p -> NodeInfo k p -> Bool

(>=) :: NodeInfo k p -> NodeInfo k p -> Bool

max :: NodeInfo k p -> NodeInfo k p -> NodeInfo k p

min :: NodeInfo k p -> NodeInfo k p -> NodeInfo k p

(Read k, Read p, Read (PatchTarget p)) => Read (NodeInfo k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

readsPrec :: Int -> ReadS (NodeInfo k p)

readList :: ReadS [NodeInfo k p]

readPrec :: ReadPrec (NodeInfo k p)

readListPrec :: ReadPrec [NodeInfo k p]

(Show k, Show p, Show (PatchTarget p)) => Show (NodeInfo k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

showsPrec :: Int -> NodeInfo k p -> ShowS

show :: NodeInfo k p -> String

showList :: [NodeInfo k p] -> ShowS

bitraverseNodeInfo :: Applicative f => (k0 -> f k1) -> (p0 -> f p1) -> (PatchTarget p0 -> f (PatchTarget p1)) -> NodeInfo k0 p0 -> f (NodeInfo k1 p1)

Traverse the NodeInfo over the key, patch, and patch target. Because of the type families here, this doesn't it any bi- or tri-traversal class.

nodeInfoMapFrom :: (From k v -> From k v) -> NodeInfo k v -> NodeInfo k v

Change the From value of a NodeInfo

nodeInfoMapMFrom :: Functor f => (From k v -> f (From k v)) -> NodeInfo k v -> f (NodeInfo k v)

Change the From value of a NodeInfo, using a Functor (or Applicative, Monad, etc.) action to get the new value

nodeInfoSetTo :: To k -> NodeInfo k v -> NodeInfo k v

Set the To field of a NodeInfo

From

data From k p

Describe how a key's new value should be produced

Constructors

From_Insert (PatchTarget p)

Insert the given value here

From_Delete

Delete the existing value, if any, from here

From_Move !k !p

Move the value here from the given key, and apply the given patch

Instances

(Eq k, Eq p, Eq (PatchTarget p)) => Eq (From k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

(==) :: From k p -> From k p -> Bool

(/=) :: From k p -> From k p -> Bool

(Ord k, Ord p, Ord (PatchTarget p)) => Ord (From k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

compare :: From k p -> From k p -> Ordering

(<) :: From k p -> From k p -> Bool

(<=) :: From k p -> From k p -> Bool

(>) :: From k p -> From k p -> Bool

(>=) :: From k p -> From k p -> Bool

max :: From k p -> From k p -> From k p

min :: From k p -> From k p -> From k p

(Read k, Read p, Read (PatchTarget p)) => Read (From k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

readsPrec :: Int -> ReadS (From k p)

readList :: ReadS [From k p]

readPrec :: ReadPrec (From k p)

readListPrec :: ReadPrec [From k p]

(Show k, Show p, Show (PatchTarget p)) => Show (From k p)

Defined in Data.Patch.MapWithPatchingMove

Methods

showsPrec :: Int -> From k p -> ShowS

show :: From k p -> String

showList :: [From k p] -> ShowS

bitraverseFrom :: Applicative f => (k0 -> f k1) -> (p0 -> f p1) -> (PatchTarget p0 -> f (PatchTarget p1)) -> From k0 p0 -> f (From k1 p1)

Traverse the From over the key, patch, and patch target. Because of the type families here, this doesn't it any bi- or tri-traversal class.

To

type To = Maybe

Describe where a key's old value will go. If this is Just, that means the key's old value will be moved to the given other key; if it is Nothing, that means it will be deleted.

data Fixup k v

Helper data structure used for composing patches using the monoid instance.

Constructors

Fixup_Delete

Fixup_Update (These (From k v) (To k))