Data.Patch.DMapWithMove

This Module contains PatchDMapWithMove k v and associated functions, which represents a Patch to a DMap k v which can insert, update, delete, and move values between keys.

Documentation

newtype 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))

Constructors

PatchDMapWithMove (DMap k1 (NodeInfo k1 v))

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

data NodeInfo (k1 :: k -> Type) (v :: k -> Type) (a :: k)

Structure which represents what changes apply to a particular key. _nodeInfo_from specifies what happens to this key, and in particular what other key the current key is moving from, while _nodeInfo_to specifies what key the current key is moving to if involved in a move.

Constructors

NodeInfo

Fields

• _nodeInfo_from :: !(From k1 v a)

  Change applying to the current key, be it an insert, move, or delete.

• _nodeInfo_to :: !(To k1 a)

  Where this key is moving to, if involved in a move. Should only be ComposeMaybe (Just k) when there is a corresponding From_Move.

Instances

(Show (v a), Show (k2 a)) => Show (NodeInfo k2 v a)

Defined in Data.Patch.DMapWithMove

Methods

showsPrec :: Int -> NodeInfo k2 v a -> ShowS

show :: NodeInfo k2 v a -> String

showList :: [NodeInfo k2 v a] -> ShowS

data From (k :: a -> Type) (v :: a -> Type) (b :: a) where

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

Constructors

From_Insert :: forall {a} (v :: a -> Type) (b :: a) (k :: a -> Type). v b -> From k v b

Insert a new or update an existing key with the given value v a

From_Delete :: forall {a} (k :: a -> Type) (v :: a -> Type) (b :: a). From k v b

Delete the existing key

From_Move :: forall {a} (k :: a -> Type) (b :: a) (v :: a -> Type). !(k b) -> From k v b

Move the value from the given key k a to this key. The source key should also have an entry in the patch giving the current key as _nodeInfo_to, usually but not necessarily with From_Delete.

Instances

(Read (v b), Read (k b)) => Read (From k v b)

Defined in Data.Patch.DMapWithMove

Methods

readsPrec :: Int -> ReadS (From k v b)

readList :: ReadS [From k v b]

readPrec :: ReadPrec (From k v b)

readListPrec :: ReadPrec [From k v b]

(Show (v b), Show (k b)) => Show (From k v b)

Defined in Data.Patch.DMapWithMove

Methods

showsPrec :: Int -> From k v b -> ShowS

show :: From k v b -> String

showList :: [From k v b] -> ShowS

(Eq (v b), Eq (k b)) => Eq (From k v b)

Defined in Data.Patch.DMapWithMove

Methods

(==) :: From k v b -> From k v b -> Bool

(/=) :: From k v b -> From k v b -> Bool

(Ord (v b), Ord (k b)) => Ord (From k v b)

Defined in Data.Patch.DMapWithMove

Methods

compare :: From k v b -> From k v b -> Ordering

(<) :: From k v b -> From k v b -> Bool

(<=) :: From k v b -> From k v b -> Bool

(>) :: From k v b -> From k v b -> Bool

(>=) :: From k v b -> From k v b -> Bool

max :: From k v b -> From k v b -> From k v b

min :: From k v b -> From k v b -> From k v b

type To = ComposeMaybe :: (k -> Type) -> k -> Type

Type alias for the "to" part of a NodeInfo. ComposeMaybe (Just k) means the key is moving to another key, ComposeMaybe Nothing for any other operation.

validPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). (GCompare k2, GShow k2) => DMap k2 (NodeInfo k2 v) -> Bool

Test whether a PatchDMapWithMove satisfies its invariants.

validationErrorsForPatchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). (GCompare k2, GShow k2) => DMap k2 (NodeInfo k2 v) -> [String]

Enumerate what reasons a PatchDMapWithMove doesn't satisfy its invariants, returning [] if it's valid.

data Pair1 (f :: k -> Type) (g :: k -> Type) (a :: k)

Higher kinded 2-tuple, identical to Data.Functor.Product from base ≥ 4.9

Constructors

Pair1 (f a) (g a)

data Fixup (k1 :: k -> Type) (v :: k -> Type) (a :: k)

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

Constructors

Fixup_Delete

Fixup_Update (These (From k1 v a) (To k1 a))

insertDMapKey :: forall {k1} k2 (a :: k1) v. k2 a -> v a -> PatchDMapWithMove k2 v

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

moveDMapKey :: forall {k1} k2 (a :: k1) (v :: k1 -> Type). GCompare k2 => k2 a -> k2 a -> PatchDMapWithMove k2 v

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

    delete src (maybe dmap (insert dst) (DMap.lookup src dmap))

swapDMapKey :: forall {k1} k2 (a :: k1) (v :: k1 -> Type). GCompare k2 => k2 a -> k2 a -> PatchDMapWithMove k2 v

Make a PatchDMapWithMove k v which has the effect of swapping two keys in the mapping, equivalent to:

    let aMay = DMap.lookup a dmap
        bMay = DMap.lookup b dmap
    in maybe id (DMap.insert a) (bMay <> aMay)
     . maybe id (DMap.insert b) (aMay <> bMay)
     . DMap.delete a . DMap.delete b $ dmap

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

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

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.

patchDMapWithMove :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type). (GCompare k2, GShow k2) => DMap k2 (NodeInfo k2 v) -> Either [String] (PatchDMapWithMove k2 v)

Wrap a DMap representing patch changes into a PatchDMapWithMove while checking invariants. If the invariants are satisfied, Right p is returned otherwise Left errors.

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

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

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

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').

nodeInfoMapFrom :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type) (a :: k1) (v' :: k1 -> Type). (From k2 v a -> From k2 v' a) -> NodeInfo k2 v a -> NodeInfo k2 v' a

Map a function which transforms From k v a into a From k v' a over a NodeInfo k v a.

nodeInfoMapFromM :: forall {k1} f (k2 :: k1 -> Type) (v :: k1 -> Type) (a :: k1) (v' :: k1 -> Type). Functor f => (From k2 v a -> f (From k2 v' a)) -> NodeInfo k2 v a -> f (NodeInfo k2 v' a)

Map an effectful function which transforms From k v a into a f (From k v' a) over a NodeInfo k v a.

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.

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.

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

getDeletionsAndMoves :: forall {k1} (k2 :: k1 -> Type) (v :: k1 -> Type) (v' :: k1 -> Type). GCompare k2 => PatchDMapWithMove k2 v -> DMap k2 v' -> DMap k2 (Product v' (ComposeMaybe k2))

Get the values that will be replaced, deleted, or moved if the given patch is applied to the given DMap.