changes

type Atomic struct {
	Value interface{}
}

type Change interface {
	// Merge takes the current change and another change that were
	// both applied to the same virtual JSON and returns
	// transformed versions such that:
	//
	//     c + otherx = other + cx
	//
	// Otherx captures the intent behind other and cx captures the
	// intent behind the current change.  The equation above
	// guarantees that the combined intent can be achieved by
	// applying the transformed changes on top of the local
	// change.
	//
	// Note that there is no requirement that c.Merge(other) and
	// other.Merge(c) should both yield the same transforms. This
	// requires that for correctness, there must be a clear way to
	// decide which change is the receiver and which is the param.
	Merge(other Change) (otherx, cx Change)

	// Revert returns the opposite effect of the current
	// change. If applied directly after the current change it
	// should undo the effect of the current change.
	Revert() Change
}

type ChangeSet []Change

type Collection interface {
	// must also implement Value
	Value

	// ApplyCollection is just strongly typed Apply
	ApplyCollection(ctx Context, c Change) Collection

	// Slice should only be called on collection-like objects such
	// as the Before/After fields of a Splice. Note that unlike
	// Go's slice notation, the arguments are offset and count.
	Slice(offset, count int) Collection

	// Count should noly be called on collection-like objects such
	// as the Before/After fields of a Splice. It returns the size
	// of the collection.
	Count() int
}

type Context interface {
	Value(key interface{}) interface{}
}

type Custom interface {
	Change

	// ReverseMerge is used when a "known" change type is merged
	// with a custom type:
	//
	//       move.Merge(myType)
	//
	// The known type has no way of figuring out how to merge. It
	// calls ReverseMerge on the custom type to get the custom
	// type to deal with this. This is separate from the regular
	// Merge method because calling "myType.Merge(move)" may not
	// be the same:  the Merge() call is not required to be
	// symmetric. A good example of a non-symmetric situation is
	// when the left change and  the right change both are
	// "inserting" into the same array at the same point -- the
	// changes will have to be ordered so that one of them ends up
	// before the other.
	//
	// Basically, if:
	//
	//       ax, bx := a.Merge(b)
	//
	// Then:
	//
	//       bx, ax := b.ReverseMerge(a)
	//
	ReverseMerge(c Change) (Change, Change)

	// ApplyTo allows custom change types to implement a method to
	// apply their changes onto known "values".  This allows Value
	// implementations to be written without awareness of all
	// possible Change implementations
	ApplyTo(ctx Context, v Value) Value
}

type Meta struct {
	Data interface{}
	Change
}

type Move struct {
	Offset, Count, Distance int
}

type PathChange struct {
	Path []interface{}
	Change
}

type Replace struct {
	Before, After Value
}

type Splice struct {
	Offset        int
	Before, After Collection
}

type Value interface {
	// Apply applies the specified change on the object and
	// returns the updated value.
	Apply(ctx Context, c Change) Value
}