patch: Data structures for describing changes to other data structures.

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

Data structures for describing changes to other data structures.

In this library, a patch is something which can be applied, analogous to a function, and which distinguishes returning the argument it was provided from returning something else.

[Skip to Readme]


Change log
Dependencies base (>=4.9 && <4.15), constraints-extras (>=0.3 && <0.4), containers (>=0.6 && <0.7), dependent-map (>=0.3 && <0.5), dependent-sum (>=0.6 && <0.8), lens (>=4.7 && <5), monoidal-containers (== || >=0.6 && <0.7), semialign (>=1 && <1.2), semigroupoids (>=4.0 && <6), these (>=0.4 && <0.9 || >=1 && <1.2), transformers (>= && <0.6), witherable (>=0.3 && <0.5) [details]
License BSD-3-Clause
Author Ryan Trinkle
Category FRP
Home page
Bug tracker
Source repo head: git clone
Uploaded by JohnEricson at 2021-12-17T22:59:00Z




Automatic Flags

Use split these/semialign packages


Use -f <flag> to enable a flag, or -f -<flag> to disable that flag. More info


Maintainer's Corner

For package maintainers and hackage trustees

Readme for patch-

[back to package description]


Haskell Hackage Hackage CI Travis CI BSD3 License

Data structures for describing changes to other data structures.

A Patch type represents a kind of change made to a data structure.

class Patch p where
  type PatchTarget p :: *
  -- | Apply the patch p a to the value a.  If no change is needed, return
  -- 'Nothing'.
  apply :: p -> PatchTarget p -> Maybe (PatchTarget p)

Patching Maps

For example, Data.Patch.Map defines the PatchMap type which can be used to patch Maps. A PatchMap represents updates to a Map that can insert, remove, or replace items in the Map. In this example, the Map is the PatchTarget and the PatchMap is the Patch. Keep in mind that there are many other possible Patches that can be applied to a Map (i.e., Map can be the PatchTarget for many different Patch instances).

PatchMap is defined as:

newtype PatchMap k v = PatchMap { unPatchMap :: Map k (Maybe v) }

The Maybe around the value is used to represent insertion/updates or deletion of the element at a given key.

Its Patch instance begins with:

instance Ord k => Patch (PatchMap k v) where
  type PatchTarget (PatchMap k v) = Map k v

When a PatchMap is applied to its PatchTarget, the following changes can occur:

There are, of course, more complicated ways of patching maps involving, for example, moving values from one key to another. You can find the code for that in Data.Patch.PatchMapWithMove. Note that the PatchTarget type associated with the PatchMapWithMove patch instance is still Map k v!