Patch combinators: A library for patching functions and data structures

A patch can be, for example

• a type constraint (an identity function with a specific type)
• a surjective function extending the domain of a function (e.g. turning a function on natural numbers into a function defined for any integer)

A typical use-case is to constrain the types of a QuickCheck property. Let's say we have a property to check associativity of addition:

 prop_addAssoc :: (Num a, Ord a) => a -> a -> a -> Bool
 prop_addAssoc a b c = (a + b) + c == a + (b + c)

In order to check that this property holds for Int8, we just say:

 *Data.Patch> quickCheck (prop_addAssoc -:: tI8 >-> id)

Note that we only had to give a partial type annotation since all arguments are required to have the same type.

Sometimes properties are only defined for a sub-set of the possible arguments. Consider the following property of enumFromTo:

 prop_enum m n = enumFromTo 0 m !! n == n

This property is only valid when m and n are natural numbers and n<=m. Instead of rewriting the property to account for arbitrary integers, we can simply apply a patch:

 quickCheck (prop_enum -:: name (\m -> abs >-> (min (abs m) . abs) >-> id))

Here name allows us to bind the first argument generated by QuickCheck. The patch uses abs to make sure that the values passed to the property are natural numbers, and min (abs m) to ensure that the second argument does not exceed the first.

The library has some similarities with Semantic editor combinators:

http://conal.net/blog/posts/semantic-editor-combinators

The main difference is that semantic editors are about locating and changing a small part of a data structure, while patches are about changing all parts of the structure. (For partial updates, use the id patch to leave sub-structures untouched.)