generalise with diff.Interface

BenchmarkDiff      ~1500 ns/op
BenchmarkDiffRunes ~1500 ns/op

Author: mb0

diff.go

@@ -6,19 +6,63 @@
 // The algorithm is described in "An O(ND) Difference Algorithm and its Variations", Eugene Myers, Algorithmica Vol. 1 No. 2, 1986, pp. 251-266.
 package diff
 
-// Diff returns the differences between two int slices.
-func Diff(a, b []int) []Change {
-	n := len(a)
-	m := len(b)
-	c := &context{a: a, b: b}
+// A type that satisfies diff.Interface can be diffed by this package.
+// It typically has two sequences A and B of comparable elements.
+type Interface interface {
+	// N is the number of elements in A, called once
+	N() int
+	// M is the number of elements in B, called once
+	M() int
+	// Equal returns whether the elements at a and b are considered equal.
+	// Called repeatedly with 0<=a<N and 0<=b<M
+	Equal(a, b int) bool
+}
+
+// Ints attaches diff.Interface methods to an array of two int slices
+type Ints [2][]int
+
+func (i *Ints) N() int {
+	return len(i[0])
+}
+func (i *Ints) M() int {
+	return len(i[1])
+}
+func (i *Ints) Equal(a, b int) bool {
+	return i[0][a] == i[1][b]
+}
+func (i *Ints) Diff() []Change {
+	return Diff(i)
+}
+
+// Runes attaches diff.Interface methods to an array of two rune slices
+type Runes [2][]rune
+
+func (r *Runes) N() int {
+	return len(r[0])
+}
+func (r *Runes) M() int {
+	return len(r[1])
+}
+func (r *Runes) Equal(a, b int) bool {
+	return r[0][a] == r[1][b]
+}
+func (r *Runes) Diff() []Change {
+	return Diff(r)
+}
+
+// Diff returns the differences of data.
+func Diff(data Interface) []Change {
+	n := data.N()
+	m := data.M()
+	c := &context{data: data}
 	if n > m {
 		c.flags = make([]byte, n)
 	} else {
 		c.flags = make([]byte, m)
 	}
 	c.max = n + m + 1
 	c.compare(0, 0, n, m)
-	return c.result()
+	return c.result(n, m)
 }
 
 // A Change contains one or more deletions or inserts
@@ -30,7 +74,7 @@ type Change struct {
 }
 
 type context struct {
-	a, b  []int  // inputs
+	data  Interface
 	flags []byte // element bits 1 delete, 2 insert
 	max   int
 	// forward and reverse d-path endpoint x components
@@ -39,12 +83,12 @@ type context struct {
 
 func (c *context) compare(aoffset, boffset, alimit, blimit int) {
 	// eat common prefix
-	for aoffset < alimit && boffset < blimit && c.a[aoffset] == c.b[boffset] {
+	for aoffset < alimit && boffset < blimit && c.data.Equal(aoffset, boffset) {
 		aoffset++
 		boffset++
 	}
 	// eat common suffix
-	for alimit > aoffset && blimit > boffset && c.a[alimit-1] == c.b[blimit-1] {
+	for alimit > aoffset && blimit > boffset && c.data.Equal(alimit-1, blimit-1) {
 		alimit--
 		blimit--
 	}
@@ -68,6 +112,7 @@ func (c *context) compare(aoffset, boffset, alimit, blimit int) {
 	c.compare(aoffset, boffset, x, y)
 	c.compare(x, y, alimit, blimit)
 }
+
 func (c *context) findMiddleSnake(aoffset, boffset, alimit, blimit int) (int, int) {
 	// midpoints
 	fmid := aoffset - boffset
@@ -94,7 +139,7 @@ func (c *context) findMiddleSnake(aoffset, boffset, alimit, blimit int) (int, in
 				x = c.forward[foff+k-1] + 1 // right
 			}
 			y = x - k
-			for x < alimit && y < blimit && c.a[x] == c.b[y] {
+			for x < alimit && y < blimit && c.data.Equal(x, y) {
 				x++
 				y++
 			}
@@ -113,7 +158,7 @@ func (c *context) findMiddleSnake(aoffset, boffset, alimit, blimit int) (int, in
 				x = c.reverse[roff+k+1] - 1 // left
 			}
 			y = x - k
-			for x > aoffset && y > boffset && c.a[x-1] == c.b[y-1] {
+			for x > aoffset && y > boffset && c.data.Equal(x-1, y-1) {
 				x--
 				y--
 			}
@@ -130,10 +175,8 @@ func (c *context) findMiddleSnake(aoffset, boffset, alimit, blimit int) (int, in
 	panic("should never be reached")
 }
 
-func (c *context) result() (res []Change) {
+func (c *context) result(n, m int) (res []Change) {
 	var x, y int
-	n := len(c.a)
-	m := len(c.b)
 	for x < n || y < m {
 		if x < n && y < m && c.flags[x]&1 == 0 && c.flags[y]&2 == 0 {
 			x++

diff_test.go

@@ -10,54 +10,70 @@ import (
 
 type testcase struct {
 	name string
-	a, b []int
+	data *Ints
 	res  []Change
 }
 
 var tests = []testcase{
 	{"shift",
-		[]int{1, 2, 3},
-		[]int{0, 1, 2, 3},
+		&Ints{
+			{1, 2, 3},
+			{0, 1, 2, 3},
+		},
 		[]Change{{0, 0, 0, 1}},
 	},
 	{"push",
-		[]int{1, 2, 3},
-		[]int{1, 2, 3, 4},
+		&Ints{
+			{1, 2, 3},
+			{1, 2, 3, 4},
+		},
 		[]Change{{3, 3, 0, 1}},
 	},
 	{"unshift",
-		[]int{0, 1, 2, 3},
-		[]int{1, 2, 3},
+		&Ints{
+			{0, 1, 2, 3},
+			{1, 2, 3},
+		},
 		[]Change{{0, 0, 1, 0}},
 	},
 	{"pop",
-		[]int{1, 2, 3, 4},
-		[]int{1, 2, 3},
+		&Ints{
+			{1, 2, 3, 4},
+			{1, 2, 3},
+		},
 		[]Change{{3, 3, 1, 0}},
 	},
 	{"all changed",
-		[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-		[]int{10, 11, 12, 13, 14},
+		&Ints{
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{10, 11, 12, 13, 14},
+		},
 		[]Change{
 			{0, 0, 10, 5},
 		},
 	},
 	{"all same",
-		[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
-		[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+		&Ints{
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+			{0, 1, 2, 3, 4, 5, 6, 7, 8, 9},
+		},
 		[]Change{},
 	},
 	{"wrap",
-		[]int{1},
-		[]int{0, 1, 2, 3},
+		&Ints{
+			{1},
+			{0, 1, 2, 3},
+		},
 		[]Change{
 			{0, 0, 0, 1},
 			{1, 2, 0, 2},
 		},
 	},
 	{"snake",
-		[]int{0, 1, 2, 3, 4, 5},
-		[]int{1, 2, 3, 4, 5, 6},
+		&Ints{
+			{0, 1, 2, 3, 4, 5},
+			{1, 2, 3, 4, 5, 6},
+		},
 		[]Change{
 			{0, 0, 1, 0},
 			{6, 5, 0, 1},
@@ -67,8 +83,10 @@ var tests = []testcase{
 	// first two traces differ from fig.1
 	// it still is a lcs and ses path
 	{"paper fig. 1",
-		[]int{1, 2, 3, 1, 2, 2, 1},
-		[]int{3, 2, 1, 2, 1, 3},
+		&Ints{
+			{1, 2, 3, 1, 2, 2, 1},
+			{3, 2, 1, 2, 1, 3},
+		},
 		[]Change{
 			{0, 0, 1, 1},
 			{2, 2, 1, 0},
@@ -80,7 +98,7 @@ var tests = []testcase{
 
 func TestDiffAB(t *testing.T) {
 	for _, test := range tests {
-		res := Diff(test.a, test.b)
+		res := test.data.Diff()
 		if len(res) != len(test.res) {
 			t.Error(test.name, "expected length", len(test.res), "for", res)
 			continue
@@ -102,7 +120,7 @@ func TestDiffBA(t *testing.T) {
 		{7, 5, 0, 1},
 	}
 	for _, test := range tests {
-		res := Diff(test.b, test.a)
+		res := Diff(&Ints{test.data[1], test.data[0]})
 		if len(res) != len(test.res) {
 			t.Error(test.name, "expected length", len(test.res), "for", res)
 			continue
@@ -120,20 +138,13 @@ func TestDiffBA(t *testing.T) {
 func BenchmarkDiff(b *testing.B) {
 	t := tests[len(tests)-1]
 	for i := 0; i < b.N; i++ {
-		Diff(t.a, t.b)
+		t.data.Diff()
 	}
 }
 
 func BenchmarkDiffRunes(b *testing.B) {
-	ta := make([]int, 7)
-	for _, r := range "1231221" {
-		ta = append(ta, int(r))
-	}
-	tb := make([]int, 6)
-	for _, r := range "321213" {
-		tb = append(tb, int(r))
-	}
+	data := &Runes{[]rune("1231221"), []rune("321213")}
 	for i := 0; i < b.N; i++ {
-		Diff(ta, tb)
+		Diff(data)
 	}
 }