Data.Incremental

class (Monoid d) <= Patch a d | a -> d where

The monoid d of changes acts on values of type a.

Members

• patch :: a -> d -> a

Instances

• Patch Unit Unit
• (Patch a da, Patch b db) => Patch (Tuple a b) (Tuple da db)

class (Patch a d) <= Diff a d | a -> d where

Members

• diff :: a -> a -> d

Instances

• Diff Unit Unit
• (Diff a da, Diff b db) => Diff (Tuple a b) (Tuple da db)

data Change a

A type level function which maps a type to the type of its change structure.

Uniqueness of instances makes the coercions fromChange and toChange safe, since the functional dependency makes the change structure type unique.

Instances

• (Patch a da, Semigroup da) => Semigroup (Change a)
• (Patch a da, Monoid da) => Monoid (Change a)

fromChange :: forall da a. Patch a da => Change a -> da

toChange :: forall da a. Patch a da => da -> Change a

type Jet a = { position :: a, velocity :: Change a }

A value (position) paired with a change (velocity).

We can think of these modified terms as conceptually similar to dual numbers.

We can use functions of type Jet a -> Jet b as incremental functions from a to b, which gives us a HOAS-style DSL for working with jets.

constant :: forall da a. Patch a da => a -> Jet a

A constant term

change :: forall da a. Patch a da => Change a -> Jet a -> Jet a

Create a function which applies a patch to its input