Data.Patch

Documentation

newtype AdditivePatch p

The elements of an Commutative Semigroup can be considered as patches of their own type.

Constructors

AdditivePatch

Fields

• unAdditivePatch :: p

Instances

Commutative p => Patch (AdditivePatch p)

Defined in Data.Patch

Associated Types

type PatchTarget (AdditivePatch p)

Defined in Data.Patch

type PatchTarget (AdditivePatch p) = p

Methods

apply :: AdditivePatch p -> PatchTarget (AdditivePatch p) -> Maybe (PatchTarget (AdditivePatch p))

type PatchTarget (AdditivePatch p)

Defined in Data.Patch

type PatchTarget (AdditivePatch p) = p

class (Semigroup q, Monoid q) => Group q where

A Group is a Monoid where every element has an inverse.

Minimal complete definition

negateG

Methods

negateG :: q -> q

(~~) :: q -> q -> q

Instances

Group ()

Trivial group.

Defined in Data.Patch

Methods

negateG :: () -> ()

(~~) :: () -> () -> ()

Group a => Group (Identity a)

Identity lifts groups pointwise (at only one point)

Defined in Data.Patch

Methods

negateG :: Identity a -> Identity a

(~~) :: Identity a -> Identity a -> Identity a

Group (Proxy x)

Trivial group, Functor style

Defined in Data.Patch

Methods

negateG :: Proxy x -> Proxy x

(~~) :: Proxy x -> Proxy x -> Proxy x

(Ord k, Group q) => Group (MonoidalMap k q)

Defined in Data.Patch

Methods

negateG :: MonoidalMap k q -> MonoidalMap k q

(~~) :: MonoidalMap k q -> MonoidalMap k q -> MonoidalMap k q

(Group a, Group b) => Group (a, b)

Product group. A Pair of groups gives rise to a group

Defined in Data.Patch

Methods

negateG :: (a, b) -> (a, b)

(~~) :: (a, b) -> (a, b) -> (a, b)

Group b => Group (a -> b)

Functions lift groups pointwise.

Defined in Data.Patch

Methods

negateG :: (a -> b) -> a -> b

(~~) :: (a -> b) -> (a -> b) -> a -> b

Group a => Group (Const a x)

Const lifts groups into a functor.

Defined in Data.Patch

Methods

negateG :: Const a x -> Const a x

(~~) :: Const a x -> Const a x -> Const a x

(Group (f a), Group (g a)) => Group ((f :*: g) a)

Product of groups, Functor style.

Defined in Data.Patch

Methods

negateG :: (f :*: g) a -> (f :*: g) a

(~~) :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a

Group (f (g a)) => Group ((f :.: g) a)

Defined in Data.Patch

Methods

negateG :: (f :.: g) a -> (f :.: g) a

(~~) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a

module Data.Patch.Class

module Data.Patch.Map

module Data.Semigroup.Additive

const2IntPatchDMapWith :: forall {k} v f (a :: k). (v -> f a) -> PatchIntMap v -> PatchDMap (Const2 Key a) f

Convert a PatchIntMap v into a PatchDMap (Const2 Int a) v' using a function v -> v' a.

const2PatchDMapWith :: forall {k1} k2 v v' (a :: k1). (v -> v' a) -> PatchMap k2 v -> PatchDMap (Const2 k2 a) v'

Convert a PatchMap k v into a PatchDMap (Const2 k a) v' using a function v -> v' a.

mapPatchDMap :: forall {k1} v v' (k2 :: k1 -> Type). (forall (a :: k1). v a -> v' a) -> PatchDMap k2 v -> PatchDMap k2 v'

Map a function v a -> v' a over any inserts/updates in the given PatchDMap k v to produce a PatchDMap k v'.

patchDMapToPatchMapWith :: forall {k1} v (a :: k1) v' k2. (v a -> v') -> PatchDMap (Const2 k2 a) v -> PatchMap k2 v'

Convert a weak PatchDMap (Const2 k a) v where the a is known by way of the Const2 into a PatchMap k v' using a rank 1 function v a -> v'.

traversePatchDMap :: forall {k1} f v v' (k2 :: k1 -> Type). Applicative f => (forall (a :: k1). v a -> f (v' a)) -> PatchDMap k2 v -> f (PatchDMap k2 v')

Map an effectful function v a -> f (v' a) over any inserts/updates in the given PatchDMap k v to produce a PatchDMap k v'.

traversePatchDMapWithKey :: forall {k1} m k2 v v'. Applicative m => (forall (a :: k1). k2 a -> v a -> m (v' a)) -> PatchDMap k2 v -> m (PatchDMap k2 v')

Map an effectful function k a -> v a -> f (v' a) over any inserts/updates in the given PatchDMap k v to produce a PatchDMap k v'.

weakenPatchDMapWith :: forall {k1} v v' (k2 :: k1 -> Type). (forall (a :: k1). v a -> v') -> PatchDMap k2 v -> PatchMap (Some k2) v'

Weaken a PatchDMap k v to a PatchMap (Some k) v' using a function v a -> v' to weaken each value contained in the patch.

const2PatchDMapWithMoveWith :: forall {k1} k2 v v' (a :: k1). (v -> v' a) -> PatchMapWithMove k2 v -> PatchDMapWithMove (Const2 k2 a) v'

Strengthen a PatchMapWithMove k v into a 'PatchDMapWithMove (Const2 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 Const2. Apply the given function to each v to produce a v' a. Completemented by patchDMapWithMoveToPatchMapWithMoveWith

mapPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) v v'. (forall (a :: k1). v a -> v' a) -> PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v'

Map a natural transform v -> v' over the given patch, transforming PatchDMapWithMove k v into PatchDMapWithMove k v'.

patchDMapWithMoveToPatchMapWithMoveWith :: forall {k1} k2 v v' (a :: k1). (v a -> v') -> PatchDMapWithMove (Const2 k2 a) v -> PatchMapWithMove k2 v'

Weaken a PatchDMapWithMove (Const2 k a) v to a PatchMapWithMove k v'. Weaken is in scare quotes because the Const2 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.

traversePatchDMapWithMoveWithKey :: forall {k1} m k2 v v'. Applicative m => (forall (a :: k1). k2 a -> v a -> m (v' a)) -> PatchDMapWithMove k2 v -> m (PatchDMapWithMove k2 v')

Map an effectful function forall a. k a -> v a -> m (v ' a) over the given patch, transforming PatchDMapWithMove k v into m (PatchDMapWithMove k v').

unPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). PatchDMapWithMove k2 v -> DMap k2 (NodeInfo k2 v)

Extract the DMap representing the patch changes from the PatchDMapWithMove.

unsafePatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). DMap k2 (NodeInfo k2 v) -> PatchDMapWithMove k2 v

Wrap a DMap representing patch changes into a PatchDMapWithMove, without checking any invariants.

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

weakenPatchDMapWithMoveWith :: forall {k1} (k2 :: k1 -> Type) v v'. (forall (a :: k1). v a -> v') -> PatchDMapWithMove k2 v -> PatchMapWithMove (Some k2) v'

Weaken a PatchDMapWithMove to a PatchMapWithMove by weakening the keys from k a to Some k and applying a given weakening function v a -> v' to values.

mapIntMapPatchWithKey :: (Int -> a -> b) -> PatchIntMap a -> PatchIntMap b

Map a function Int -> a -> b over all as in the given PatchIntMap a (that is, all inserts/updates), producing a PatchIntMap b.

patchIntMapNewElements :: PatchIntMap a -> [a]

Extract all as inserted/updated by the given PatchIntMap a.

patchIntMapNewElementsMap :: PatchIntMap a -> IntMap a

Convert the given PatchIntMap a into an IntMap a with all the inserts/updates in the given patch.

traverseIntMapPatchWithKey :: Applicative f => (Int -> a -> f b) -> PatchIntMap a -> f (PatchIntMap b)

Map an effectful function Int -> a -> f b over all as in the given PatchIntMap a (that is, all inserts/updates), producing a f (PatchIntMap b).

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.

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.

newtype PatchDMap (k1 :: k -> Type) (v :: k -> Type)

A set of changes to a DMap. Any element may be inserted/updated or deleted. Insertions are represented as ComposeMaybe (Just value), while deletions are represented as ComposeMaybe Nothing.

Constructors

PatchDMap

Fields

• unPatchDMap :: DMap k1 (ComposeMaybe v)

Instances

GCompare k2 => Monoid (PatchDMap k2 v)

Defined in Data.Patch.DMap

Methods

mempty :: PatchDMap k2 v

mappend :: PatchDMap k2 v -> PatchDMap k2 v -> PatchDMap k2 v

mconcat :: [PatchDMap k2 v] -> PatchDMap k2 v

GCompare k2 => Semigroup (PatchDMap k2 v)

Defined in Data.Patch.DMap

Methods

(<>) :: PatchDMap k2 v -> PatchDMap k2 v -> PatchDMap k2 v

sconcat :: NonEmpty (PatchDMap k2 v) -> PatchDMap k2 v

stimes :: Integral b => b -> PatchDMap k2 v -> PatchDMap k2 v

GCompare k2 => DecidablyEmpty (PatchDMap k2 v)

Defined in Data.Patch.DMap

Methods

isEmpty :: PatchDMap k2 v -> Bool

GCompare k2 => Patch (PatchDMap k2 v)

Apply the insertions or deletions to a given DMap.

Defined in Data.Patch.DMap

Associated Types

type PatchTarget (PatchDMap k2 v)

Defined in Data.Patch.DMap

type PatchTarget (PatchDMap k2 v) = DMap k2 v

Methods

apply :: PatchDMap k2 v -> PatchTarget (PatchDMap k2 v) -> Maybe (PatchTarget (PatchDMap k2 v))

type PatchTarget (PatchDMap k2 v)

Defined in Data.Patch.DMap

type PatchTarget (PatchDMap k2 v) = DMap k2 v

data PatchDMapWithMove (k1 :: k -> Type) (v :: k -> Type)

Like PatchMapWithMove, but for DMap. Each key carries a NodeInfo which describes how it will be changed by the patch and connects move sources and destinations.

Invariants:

• A key should not move to itself.
• A move should always be represented with both the destination key (as a From_Move) and the source key (as a ComposeMaybe (Just destination))

Instances

GCompare k2 => Monoid (PatchDMapWithMove k2 v)

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

Defined in Data.Patch.DMapWithMove

Methods

mempty :: PatchDMapWithMove k2 v

mappend :: PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v

mconcat :: [PatchDMapWithMove k2 v] -> PatchDMapWithMove k2 v

GCompare k2 => Semigroup (PatchDMapWithMove k2 v)

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

Defined in Data.Patch.DMapWithMove

Methods

(<>) :: PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v

sconcat :: NonEmpty (PatchDMapWithMove k2 v) -> PatchDMapWithMove k2 v

stimes :: Integral b => b -> PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v

(GEq k2, Has' Eq k2 (NodeInfo k2 v)) => Eq (PatchDMapWithMove k2 v)

Test whether two PatchDMapWithMove k v contain the same patch operations.

Defined in Data.Patch.DMapWithMove

Methods

(==) :: PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v -> Bool

(/=) :: PatchDMapWithMove k2 v -> PatchDMapWithMove k2 v -> Bool

GCompare k2 => DecidablyEmpty (PatchDMapWithMove k2 v)

Defined in Data.Patch.DMapWithMove

Methods

isEmpty :: PatchDMapWithMove k2 v -> Bool

GCompare k2 => Patch (PatchDMapWithMove k2 v)

Apply the insertions, deletions, and moves to a given DMap.

Defined in Data.Patch.DMapWithMove

Associated Types

type PatchTarget (PatchDMapWithMove k2 v)

Defined in Data.Patch.DMapWithMove

type PatchTarget (PatchDMapWithMove k2 v) = DMap k2 v

Methods

apply :: PatchDMapWithMove k2 v -> PatchTarget (PatchDMapWithMove k2 v) -> Maybe (PatchTarget (PatchDMapWithMove k2 v))

type PatchTarget (PatchDMapWithMove k2 v)

Defined in Data.Patch.DMapWithMove

type PatchTarget (PatchDMapWithMove k2 v) = DMap k2 v

newtype PatchIntMap a

Patch for IntMap 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.

Constructors

PatchIntMap

Fields

• unPatchIntMap :: IntMap (Maybe a)

Instances

Functor PatchIntMap

Defined in Data.Patch.IntMap

Methods

fmap :: (a -> b) -> PatchIntMap a -> PatchIntMap b

(<$) :: a -> PatchIntMap b -> PatchIntMap a

Foldable PatchIntMap

Defined in Data.Patch.IntMap

Methods

fold :: Monoid m => PatchIntMap m -> m

foldMap :: Monoid m => (a -> m) -> PatchIntMap a -> m

foldMap' :: Monoid m => (a -> m) -> PatchIntMap a -> m

foldr :: (a -> b -> b) -> b -> PatchIntMap a -> b

foldr' :: (a -> b -> b) -> b -> PatchIntMap a -> b

foldl :: (b -> a -> b) -> b -> PatchIntMap a -> b

foldl' :: (b -> a -> b) -> b -> PatchIntMap a -> b

foldr1 :: (a -> a -> a) -> PatchIntMap a -> a

foldl1 :: (a -> a -> a) -> PatchIntMap a -> a

toList :: PatchIntMap a -> [a]

null :: PatchIntMap a -> Bool

length :: PatchIntMap a -> Int

elem :: Eq a => a -> PatchIntMap a -> Bool

maximum :: Ord a => PatchIntMap a -> a

minimum :: Ord a => PatchIntMap a -> a

sum :: Num a => PatchIntMap a -> a

product :: Num a => PatchIntMap a -> a

Traversable PatchIntMap

Defined in Data.Patch.IntMap

Methods

traverse :: Applicative f => (a -> f b) -> PatchIntMap a -> f (PatchIntMap b)

sequenceA :: Applicative f => PatchIntMap (f a) -> f (PatchIntMap a)

mapM :: Monad m => (a -> m b) -> PatchIntMap a -> m (PatchIntMap b)

sequence :: Monad m => PatchIntMap (m a) -> m (PatchIntMap a)

FoldableWithIndex Int PatchIntMap

Defined in Data.Patch.IntMap

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> PatchIntMap a -> m

ifoldMap' :: Monoid m => (Int -> a -> m) -> PatchIntMap a -> m

ifoldr :: (Int -> a -> b -> b) -> b -> PatchIntMap a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> PatchIntMap a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> PatchIntMap a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> PatchIntMap a -> b

FunctorWithIndex Int PatchIntMap

Defined in Data.Patch.IntMap

Methods

imap :: (Int -> a -> b) -> PatchIntMap a -> PatchIntMap b

TraversableWithIndex Int PatchIntMap

Defined in Data.Patch.IntMap

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> PatchIntMap a -> f (PatchIntMap b)

Monoid (PatchIntMap a)

Defined in Data.Patch.IntMap

Methods

mempty :: PatchIntMap a

mappend :: PatchIntMap a -> PatchIntMap a -> PatchIntMap a

mconcat :: [PatchIntMap a] -> PatchIntMap a

Semigroup (PatchIntMap v)

a <> 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.

Defined in Data.Patch.IntMap

Methods

(<>) :: PatchIntMap v -> PatchIntMap v -> PatchIntMap v

sconcat :: NonEmpty (PatchIntMap v) -> PatchIntMap v

stimes :: Integral b => b -> PatchIntMap v -> PatchIntMap v

Read a => Read (PatchIntMap a)

Defined in Data.Patch.IntMap

Methods

readsPrec :: Int -> ReadS (PatchIntMap a)

readList :: ReadS [PatchIntMap a]

readPrec :: ReadPrec (PatchIntMap a)

readListPrec :: ReadPrec [PatchIntMap a]

Show a => Show (PatchIntMap a)

Defined in Data.Patch.IntMap

Methods

showsPrec :: Int -> PatchIntMap a -> ShowS

show :: PatchIntMap a -> String

showList :: [PatchIntMap a] -> ShowS

Eq a => Eq (PatchIntMap a)

Defined in Data.Patch.IntMap

Methods

(==) :: PatchIntMap a -> PatchIntMap a -> Bool

(/=) :: PatchIntMap a -> PatchIntMap a -> Bool

Ord a => Ord (PatchIntMap a)

Defined in Data.Patch.IntMap

Methods

compare :: PatchIntMap a -> PatchIntMap a -> Ordering

(<) :: PatchIntMap a -> PatchIntMap a -> Bool

(<=) :: PatchIntMap a -> PatchIntMap a -> Bool

(>) :: PatchIntMap a -> PatchIntMap a -> Bool

(>=) :: PatchIntMap a -> PatchIntMap a -> Bool

max :: PatchIntMap a -> PatchIntMap a -> PatchIntMap a

min :: PatchIntMap a -> PatchIntMap a -> PatchIntMap a

Wrapped (PatchIntMap a)

Defined in Data.Patch.IntMap

Associated Types

type Unwrapped (PatchIntMap a)

Defined in Data.Patch.IntMap

type Unwrapped (PatchIntMap a) = IntMap (Maybe a)

Methods

_Wrapped' :: Iso' (PatchIntMap a) (Unwrapped (PatchIntMap a))

DecidablyEmpty (PatchIntMap a)

Defined in Data.Patch.IntMap

Methods

isEmpty :: PatchIntMap a -> Bool

Patch (PatchIntMap a)

Apply the insertions or deletions to a given IntMap.

Defined in Data.Patch.IntMap

Associated Types

type PatchTarget (PatchIntMap a)

Defined in Data.Patch.IntMap

type PatchTarget (PatchIntMap a) = IntMap a

Methods

apply :: PatchIntMap a -> PatchTarget (PatchIntMap a) -> Maybe (PatchTarget (PatchIntMap a))

PatchIntMap a1 ~ t => Rewrapped (PatchIntMap a2) t

Defined in Data.Patch.IntMap

type Unwrapped (PatchIntMap a)

Defined in Data.Patch.IntMap

type Unwrapped (PatchIntMap a) = IntMap (Maybe a)

type PatchTarget (PatchIntMap a)

Defined in Data.Patch.IntMap

type PatchTarget (PatchIntMap a) = IntMap a

data PatchMapWithMove k v

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.

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)

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

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)

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)

Defined in Data.Patch.MapWithMove

type Unwrapped (PatchMapWithMove k v) = PatchMapWithPatchingMove k (Proxy 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)

Defined in Data.Patch.MapWithMove

type PatchTarget (PatchMapWithMove k v) = Map 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