Reflex.Patch

This module defines the Patch class, which is used by Reflex to manage changes to Incremental values.

Documentation

newtype AdditivePatch p

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

Constructors

AdditivePatch

Fields

• unAdditivePatch :: p

Instances

Additive p => Patch (AdditivePatch p)

Defined in Reflex.Patch

Associated Types

type PatchTarget (AdditivePatch p) :: *

Methods

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

type PatchTarget (AdditivePatch p)

Defined in Reflex.Patch

type PatchTarget (AdditivePatch p) = p

class Semigroup q => Additive q

An Additive Semigroup is one where (<>) is commutative

Instances

Additive SelectedCount

Defined in Reflex.Query.Class

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

Defined in Data.AppendMap

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 SelectedCount

Defined in Reflex.Query.Class

Methods

negateG :: SelectedCount -> SelectedCount

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

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

Defined in Data.AppendMap

Methods

negateG :: MonoidalMap k q -> MonoidalMap k q

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

class Patch p where

A Patch type represents a kind of change made to a datastructure.

If an instance of Patch is also an instance of Semigroup, it should obey the law that applyAlways (f <> g) == applyAlways f . applyAlways g.

Minimal complete definition

apply

Associated Types

type PatchTarget p :: *

Methods

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

Apply the patch p a to the value a. If no change is needed, return Nothing.

Instances

Patch (Identity a)

Identity can be used as a Patch that always fully replaces the value

Defined in Reflex.Patch.Class

Associated Types

type PatchTarget (Identity a) :: *

Methods

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

Patch (PatchIntMap a)

Apply the insertions or deletions to a given IntMap.

Defined in Reflex.Patch.IntMap

Associated Types

type PatchTarget (PatchIntMap a) :: *

Methods

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

Additive p => Patch (AdditivePatch p)

Defined in Reflex.Patch

Associated Types

type PatchTarget (AdditivePatch p) :: *

Methods

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

Ord k => Patch (PatchMap k v)

Apply the insertions or deletions to a given Map.

Defined in Reflex.Patch.Map

Associated Types

type PatchTarget (PatchMap k v) :: *

Methods

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

Ord k => Patch (PatchMapWithMove k v)

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

Defined in Reflex.Patch.MapWithMove

Associated Types

type PatchTarget (PatchMapWithMove k v) :: *

Methods

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

GCompare k2 => Patch (PatchDMap k2 v)

Apply the insertions or deletions to a given DMap.

Defined in Reflex.Patch.DMap

Associated Types

type PatchTarget (PatchDMap k2 v) :: *

Methods

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

GCompare k2 => Patch (PatchDMapWithMove k2 v)

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

Defined in Reflex.Patch.DMapWithMove

Associated Types

type PatchTarget (PatchDMapWithMove k2 v) :: *

Methods

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

applyAlways :: Patch p => p -> PatchTarget p -> PatchTarget p

Apply a Patch; if it does nothing, return the original value

composePatchFunctions :: (Patch p, Semigroup p) => (PatchTarget p -> p) -> (PatchTarget p -> p) -> PatchTarget p -> p

Like '(.)', 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 '(.)'.

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 (IntMap (Maybe a))

Instances

Functor PatchIntMap

Defined in Reflex.Patch.IntMap

Methods

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

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

Foldable PatchIntMap

Defined in Reflex.Patch.IntMap

Methods

fold :: Monoid m => PatchIntMap m -> 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 Reflex.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)

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

Methods

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

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

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

Monoid (PatchIntMap a)

Defined in Reflex.Patch.IntMap

Methods

mempty :: PatchIntMap a

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

mconcat :: [PatchIntMap a] -> PatchIntMap a

Patch (PatchIntMap a)

Apply the insertions or deletions to a given IntMap.

Defined in Reflex.Patch.IntMap

Associated Types

type PatchTarget (PatchIntMap a) :: *

Methods

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

type PatchTarget (PatchIntMap a)

Defined in Reflex.Patch.IntMap

type PatchTarget (PatchIntMap a) = IntMap a

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.

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

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.

newtype PatchMap k v

A set of changes to a Map. Any element may be inserted/updated or deleted. Insertions are represented as values wrapped in Just, while deletions are represented as Nothings

Constructors

PatchMap

Fields

• unPatchMap :: Map k (Maybe v)

Instances

Functor (PatchMap k)

fmapping a PatchMap will alter all of the values it will insert. Deletions are unaffected.

Defined in Reflex.Patch.Map

Methods

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

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

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

Defined in Reflex.Patch.Map

Methods

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

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

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

Defined in Reflex.Patch.Map

Methods

compare :: PatchMap k v -> PatchMap k v -> Ordering

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

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

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

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

max :: PatchMap k v -> PatchMap k v -> PatchMap k v

min :: PatchMap k v -> PatchMap k v -> PatchMap k v

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

Defined in Reflex.Patch.Map

Methods

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

readList :: ReadS [PatchMap k v]

readPrec :: ReadPrec (PatchMap k v)

readListPrec :: ReadPrec [PatchMap k v]

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

Defined in Reflex.Patch.Map

Methods

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

show :: PatchMap k v -> String

showList :: [PatchMap k v] -> ShowS

Ord k => Semigroup (PatchMap k 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 Reflex.Patch.Map

Methods

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

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

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

Ord k => Monoid (PatchMap k v)

The empty PatchMap contains no insertions or deletions

Defined in Reflex.Patch.Map

Methods

mempty :: PatchMap k v

mappend :: PatchMap k v -> PatchMap k v -> PatchMap k v

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

Ord k => Patch (PatchMap k v)

Apply the insertions or deletions to a given Map.

Defined in Reflex.Patch.Map

Associated Types

type PatchTarget (PatchMap k v) :: *

Methods

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

type PatchTarget (PatchMap k v)

Defined in Reflex.Patch.Map

type PatchTarget (PatchMap k v) = Map k v

patchMapNewElements :: PatchMap k v -> [v]

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

patchMapNewElementsMap :: PatchMap k v -> Map k v

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

newtype PatchDMap k v

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 k (ComposeMaybe v)

Instances

GCompare k2 => Semigroup (PatchDMap k2 v)

Defined in Reflex.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 => Monoid (PatchDMap k2 v)

Defined in Reflex.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 => Patch (PatchDMap k2 v)

Apply the insertions or deletions to a given DMap.

Defined in Reflex.Patch.DMap

Associated Types

type PatchTarget (PatchDMap k2 v) :: *

Methods

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

type PatchTarget (PatchDMap k2 v)

Defined in Reflex.Patch.DMap

type PatchTarget (PatchDMap k2 v) = DMap k2 v

mapPatchDMap :: (forall a. v a -> v' a) -> PatchDMap k v -> PatchDMap k v'

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

traversePatchDMap :: Applicative f => (forall a. v a -> f (v' a)) -> PatchDMap k v -> f (PatchDMap k 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 :: Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMap k v -> m (PatchDMap k 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 a. v a -> v') -> PatchDMap k v -> PatchMap (Some k) 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.

patchDMapToPatchMapWith :: (v a -> v') -> PatchDMap (Const2 k a) v -> PatchMap k 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'.

const2PatchDMapWith :: forall k v v' a. (v -> v' a) -> PatchMap k v -> PatchDMap (Const2 k a) v'

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

const2IntPatchDMapWith :: forall v f a. (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.

data PatchMapWithMove k v

Patch a DMap 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

Functor (PatchMapWithMove k)

Defined in Reflex.Patch.MapWithMove

Methods

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

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

Foldable (PatchMapWithMove k)

Defined in Reflex.Patch.MapWithMove

Methods

fold :: Monoid m => PatchMapWithMove k m -> 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 Reflex.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)

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

Defined in Reflex.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 Reflex.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

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

Defined in Reflex.Patch.MapWithMove

Methods

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

show :: PatchMapWithMove k v -> String

showList :: [PatchMapWithMove k v] -> ShowS

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 Reflex.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 => Monoid (PatchMapWithMove k v)

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

Defined in Reflex.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 => Patch (PatchMapWithMove k v)

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

Defined in Reflex.Patch.MapWithMove

Associated Types

type PatchTarget (PatchMapWithMove k v) :: *

Methods

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

type PatchTarget (PatchMapWithMove k v)

Defined in Reflex.Patch.MapWithMove

type PatchTarget (PatchMapWithMove k v) = Map k v

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

Extract the internal representation of the PatchMapWithMove

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.

data PatchDMapWithMove k v

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

EqTag k2 (NodeInfo k2 v) => Eq (PatchDMapWithMove k2 v)

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

Defined in Reflex.Patch.DMapWithMove

Methods

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

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

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

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 Reflex.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 => Patch (PatchDMapWithMove k2 v)

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

Defined in Reflex.Patch.DMapWithMove

Associated Types

type PatchTarget (PatchDMapWithMove k2 v) :: *

Methods

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

type PatchTarget (PatchDMapWithMove k2 v)

Defined in Reflex.Patch.DMapWithMove

type PatchTarget (PatchDMapWithMove k2 v) = DMap k2 v

unPatchDMapWithMove :: PatchDMapWithMove k v -> DMap k (NodeInfo k v)

Extract the DMap representing the patch changes from the PatchDMapWithMove.

unsafePatchDMapWithMove :: DMap k (NodeInfo k v) -> PatchDMapWithMove k 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.

mapPatchDMapWithMove :: forall k v v'. (forall a. v a -> v' a) -> PatchDMapWithMove k v -> PatchDMapWithMove k v'

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

traversePatchDMapWithMoveWithKey :: forall m k v v'. Applicative m => (forall a. k a -> v a -> m (v' a)) -> PatchDMapWithMove k v -> m (PatchDMapWithMove k 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').

weakenPatchDMapWithMoveWith :: forall k v v'. (forall a. v a -> v') -> PatchDMapWithMove k v -> PatchMapWithMove (Some k) 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 k v v' a. (v a -> v') -> PatchDMapWithMove (Const2 k a) v -> PatchMapWithMove k 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 k v v' a. (v -> v' a) -> PatchMapWithMove k v -> PatchDMapWithMove (Const2 k 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