Data.Patch.MapWithMove

Patches of this type can insert, delete, and also move values from one key to another.

Documentation

newtype PatchMapWithMove k (v :: Type)

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

PatchMapWithMove'

Fields

• unPatchMapWithMove' :: PatchMapWithPatchingMove k (Proxy v)

  Extract the underlying 'PatchMapWithPatchingMove k (Proxy v)'

Bundled Patterns

pattern PatchMapWithMove :: Map k (NodeInfo k v) -> PatchMapWithMove k v

Instances

FoldableWithIndex k (PatchMapWithMove k)

Defined in Data.Patch.MapWithMove

Methods

ifoldMap :: Monoid m => (k -> a -> m) -> PatchMapWithMove k a -> m

ifoldMap' :: Monoid m => (k -> a -> m) -> PatchMapWithMove k a -> m

ifoldr :: (k -> a -> b -> b) -> b -> PatchMapWithMove k a -> b

ifoldl :: (k -> b -> a -> b) -> b -> PatchMapWithMove k a -> b

ifoldr' :: (k -> a -> b -> b) -> b -> PatchMapWithMove k a -> b

ifoldl' :: (k -> b -> a -> b) -> b -> PatchMapWithMove k a -> b

FunctorWithIndex k (PatchMapWithMove k)

Defined in Data.Patch.MapWithMove

Methods

imap :: (k -> a -> b) -> PatchMapWithMove k a -> PatchMapWithMove k b

TraversableWithIndex k (PatchMapWithMove k)

Defined in Data.Patch.MapWithMove

Methods

itraverse :: Applicative f => (k -> a -> f b) -> PatchMapWithMove k a -> f (PatchMapWithMove k b)

Foldable (PatchMapWithMove k)

Defined in Data.Patch.MapWithMove

Methods

fold :: Monoid m => PatchMapWithMove k m -> m

foldMap :: Monoid m => (a -> m) -> PatchMapWithMove k a -> m

foldMap' :: Monoid m => (a -> m) -> PatchMapWithMove k a -> m

foldr :: (a -> b -> b) -> b -> PatchMapWithMove k a -> b

foldr' :: (a -> b -> b) -> b -> PatchMapWithMove k a -> b

foldl :: (b -> a -> b) -> b -> PatchMapWithMove k a -> b

foldl' :: (b -> a -> b) -> b -> PatchMapWithMove k a -> b

foldr1 :: (a -> a -> a) -> PatchMapWithMove k a -> a

foldl1 :: (a -> a -> a) -> PatchMapWithMove k a -> a

toList :: PatchMapWithMove k a -> [a]

null :: PatchMapWithMove k a -> Bool

length :: PatchMapWithMove k a -> Int

elem :: Eq a => a -> PatchMapWithMove k a -> Bool

maximum :: Ord a => PatchMapWithMove k a -> a

minimum :: Ord a => PatchMapWithMove k a -> a

sum :: Num a => PatchMapWithMove k a -> a

product :: Num a => PatchMapWithMove k a -> a

Traversable (PatchMapWithMove k)

Defined in Data.Patch.MapWithMove

Methods

traverse :: Applicative f => (a -> f b) -> PatchMapWithMove k a -> f (PatchMapWithMove k b)

sequenceA :: Applicative f => PatchMapWithMove k (f a) -> f (PatchMapWithMove k a)

mapM :: Monad m => (a -> m b) -> PatchMapWithMove k a -> m (PatchMapWithMove k b)

sequence :: Monad m => PatchMapWithMove k (m a) -> m (PatchMapWithMove k a)

Functor (PatchMapWithMove k)

Defined in Data.Patch.MapWithMove

Methods

fmap :: (a -> b) -> PatchMapWithMove k a -> PatchMapWithMove k b

(<$) :: a -> PatchMapWithMove k b -> PatchMapWithMove k a

Ord k => Monoid (PatchMapWithMove k v)

Defined in Data.Patch.MapWithMove

Methods

mempty :: PatchMapWithMove k v

mappend :: PatchMapWithMove k v -> PatchMapWithMove k v -> PatchMapWithMove k v

mconcat :: [PatchMapWithMove k v] -> PatchMapWithMove k v

Ord k => Semigroup (PatchMapWithMove k v)

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

Defined in Data.Patch.MapWithMove

Methods

(<>) :: PatchMapWithMove k v -> PatchMapWithMove k v -> PatchMapWithMove k v

sconcat :: NonEmpty (PatchMapWithMove k v) -> PatchMapWithMove k v

stimes :: Integral b => b -> PatchMapWithMove k v -> PatchMapWithMove k v

(Ord k, Read k, Read v) => Read (PatchMapWithMove k v)

Defined in Data.Patch.MapWithMove

Methods

readsPrec :: Int -> ReadS (PatchMapWithMove k v)

readList :: ReadS [PatchMapWithMove k v]

readPrec :: ReadPrec (PatchMapWithMove k v)

readListPrec :: ReadPrec [PatchMapWithMove k v]

(Show k, Show v) => Show (PatchMapWithMove k v)

Defined in Data.Patch.MapWithMove

Methods

showsPrec :: Int -> PatchMapWithMove k v -> ShowS

show :: PatchMapWithMove k v -> String

showList :: [PatchMapWithMove k v] -> ShowS

(Eq k, Eq v) => Eq (PatchMapWithMove k v)

Defined in Data.Patch.MapWithMove

Methods

(==) :: PatchMapWithMove k v -> PatchMapWithMove k v -> Bool

(/=) :: PatchMapWithMove k v -> PatchMapWithMove k v -> Bool

(Ord k, Ord v) => Ord (PatchMapWithMove k v)

Defined in Data.Patch.MapWithMove

Methods

compare :: PatchMapWithMove k v -> PatchMapWithMove k v -> Ordering

(<) :: PatchMapWithMove k v -> PatchMapWithMove k v -> Bool

(<=) :: PatchMapWithMove k v -> PatchMapWithMove k v -> Bool

(>) :: PatchMapWithMove k v -> PatchMapWithMove k v -> Bool

(>=) :: PatchMapWithMove k v -> PatchMapWithMove k v -> Bool

max :: PatchMapWithMove k v -> PatchMapWithMove k v -> PatchMapWithMove k v

min :: PatchMapWithMove k v -> PatchMapWithMove k v -> PatchMapWithMove k v

Wrapped (PatchMapWithMove k v)

Defined in Data.Patch.MapWithMove

Associated Types

type Unwrapped (PatchMapWithMove k v)

Methods

_Wrapped' :: Iso' (PatchMapWithMove k v) (Unwrapped (PatchMapWithMove k v))

Ord k => Patch (PatchMapWithMove k v)

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

Defined in Data.Patch.MapWithMove

Associated Types

type PatchTarget (PatchMapWithMove k v)

Methods

apply :: PatchMapWithMove k v -> PatchTarget (PatchMapWithMove k v) -> Maybe (PatchTarget (PatchMapWithMove k v))

PatchMapWithMove k1 v1 ~ t => Rewrapped (PatchMapWithMove k2 v2) t

Defined in Data.Patch.MapWithMove

type Unwrapped (PatchMapWithMove k v)

Defined in Data.Patch.MapWithMove

type Unwrapped (PatchMapWithMove k v) = PatchMapWithPatchingMove k (Proxy v)

type PatchTarget (PatchMapWithMove k v)

Defined in Data.Patch.MapWithMove

type PatchTarget (PatchMapWithMove k v) = Map k v

patchMapWithMove :: Ord k => Map k (NodeInfo k v) -> Maybe (PatchMapWithMove k v)

Create a PatchMapWithMove, validating it

patchMapWithMoveInsertAll :: Map k v -> PatchMapWithMove k v

Create a PatchMapWithMove that inserts everything in the given Map

insertMapKey :: k -> v -> PatchMapWithMove k v

Make a PatchMapWithMove k v which has the effect of inserting or updating a value v to the given key k, like insert.

moveMapKey :: Ord k => k -> k -> PatchMapWithMove k v

Make a PatchMapWithMove k v 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))

swapMapKey :: Ord k => k -> k -> PatchMapWithMove k v

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

deleteMapKey :: k -> PatchMapWithMove k v

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

unsafePatchMapWithMove :: Map k (NodeInfo k v) -> PatchMapWithMove k v

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

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

patchMapWithMoveNewElements :: PatchMapWithMove k v -> [v]

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

patchMapWithMoveNewElementsMap :: PatchMapWithMove k v -> Map k v

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

patchThatSortsMapWith :: Ord k => (v -> v -> Ordering) -> Map k v -> PatchMapWithMove k v

Create a PatchMapWithMove 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 :: (Ord k, Ord v) => (v -> v -> Ordering) -> Map k v -> Map k v -> PatchMapWithMove k v

Create a PatchMapWithMove 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 :: (Ord k, Ord v) => Map k v -> Map k v -> PatchMapWithMove k v

Create a PatchMapWithMove that, if applied to the first Map provided, will produce the second Map.

Node Info

newtype NodeInfo k (v :: Type)

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

Constructors

NodeInfo'

Fields

• unNodeInfo' :: NodeInfo k (Proxy v)

Bundled Patterns

pattern NodeInfo :: From k v -> To k -> NodeInfo k v

Instances

Foldable (NodeInfo k)

Defined in Data.Patch.MapWithMove

Methods

fold :: Monoid m => NodeInfo k m -> m

foldMap :: Monoid m => (a -> m) -> NodeInfo k a -> m

foldMap' :: Monoid m => (a -> m) -> NodeInfo k a -> m

foldr :: (a -> b -> b) -> b -> NodeInfo k a -> b

foldr' :: (a -> b -> b) -> b -> NodeInfo k a -> b

foldl :: (b -> a -> b) -> b -> NodeInfo k a -> b

foldl' :: (b -> a -> b) -> b -> NodeInfo k a -> b

foldr1 :: (a -> a -> a) -> NodeInfo k a -> a

foldl1 :: (a -> a -> a) -> NodeInfo k a -> a

toList :: NodeInfo k a -> [a]

null :: NodeInfo k a -> Bool

length :: NodeInfo k a -> Int

elem :: Eq a => a -> NodeInfo k a -> Bool

maximum :: Ord a => NodeInfo k a -> a

minimum :: Ord a => NodeInfo k a -> a

sum :: Num a => NodeInfo k a -> a

product :: Num a => NodeInfo k a -> a

Traversable (NodeInfo k)

Defined in Data.Patch.MapWithMove

Methods

traverse :: Applicative f => (a -> f b) -> NodeInfo k a -> f (NodeInfo k b)

sequenceA :: Applicative f => NodeInfo k (f a) -> f (NodeInfo k a)

mapM :: Monad m => (a -> m b) -> NodeInfo k a -> m (NodeInfo k b)

sequence :: Monad m => NodeInfo k (m a) -> m (NodeInfo k a)

Functor (NodeInfo k)

Defined in Data.Patch.MapWithMove

Methods

fmap :: (a -> b) -> NodeInfo k a -> NodeInfo k b

(<$) :: a -> NodeInfo k b -> NodeInfo k a

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

Defined in Data.Patch.MapWithMove

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 (NodeInfo k p)

Defined in Data.Patch.MapWithMove

Methods

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

show :: NodeInfo k p -> String

showList :: [NodeInfo k p] -> ShowS

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

Defined in Data.Patch.MapWithMove

Methods

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

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

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

Defined in Data.Patch.MapWithMove

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

Wrapped (NodeInfo k v)

Defined in Data.Patch.MapWithMove

Associated Types

type Unwrapped (NodeInfo k v)

Methods

_Wrapped' :: Iso' (NodeInfo k v) (Unwrapped (NodeInfo k v))

NodeInfo k1 v1 ~ t => Rewrapped (NodeInfo k2 v2) t

Defined in Data.Patch.MapWithMove

type Unwrapped (NodeInfo k v)

Defined in Data.Patch.MapWithMove

type Unwrapped (NodeInfo k v) = NodeInfo k (Proxy v)

bitraverseNodeInfo :: Applicative f => (k0 -> f k1) -> (v0 -> f v1) -> NodeInfo k0 v0 -> f (NodeInfo k1 v1)

Like bitraverse

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

newtype From k (v :: Type)

Describe how a key's new value should be produced

Constructors

From'

Fields

• unFrom' :: From k (Proxy v)

Bundled Patterns

pattern From_Insert :: v -> From k v

Insert the given value here

pattern From_Delete :: From k v

Delete the existing value, if any, from here

pattern From_Move :: k -> From k v

Move the value here from the given key

Instances

Wrapped (From k v)

Defined in Data.Patch.MapWithMove

Associated Types

type Unwrapped (From k v)

Methods

_Wrapped' :: Iso' (From k v) (Unwrapped (From k v))

From k1 v1 ~ t => Rewrapped (From k2 v2) t

Defined in Data.Patch.MapWithMove

type Unwrapped (From k v)

Defined in Data.Patch.MapWithMove

type Unwrapped (From k v) = From k (Proxy v)

bitraverseFrom :: Applicative f => (k0 -> f k1) -> (v0 -> f v1) -> From k0 v0 -> f (From k1 v1)

Like bitraverse

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.