simplify api

Author: mb0

README.md

@@ -10,23 +10,21 @@ Example
 -------
 You can use diff.Ints and diff.Runes
 
-    d := &diff.Runes{[]rune("sögen"), []rune("mögen")}
-    d.Diff() // returns []Changes{{0,0,1,1}}
+    diff.Runes([]rune("sögen"), []rune("mögen")) // returns []Changes{{0,0,1,1}}
 
-or you can implement diff.Interface and use diff.Diff(data)
+or you can implement diff.Data
 
     type MixedInput struct {
     	A []int
     	B []string
     }
-    func (m *MixedInput) N() int {
-    	return len(m.A)
-    }
-    func (m *MixedInput) M() int {
-    	return len(m.B)
-    }
-    func (m *MixedInput) Equal(a, b int) bool {
-    	return m.A[a] == len(m.B[b])
+    func (m *MixedInput) Equal(i, j int) bool {
+    	return m.A[i] == len(m.B[j])
     }
 
+and call
+
+    m := &MixedInput{..}
+    diff.Diff(len(m.A), len(m.B), m)
+
 Documentation at http://go.pkgdoc.org/github.com/mb0/diff

diff.go

@@ -6,54 +6,34 @@
 // 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
 
-// A type that satisfies diff.Interface can be diffed by this package.
+// A type that satisfies diff.Data 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
+type Data interface {
+	// Equal returns whether the elements at i and j are considered equal.
+	Equal(i, j 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)
+// Ints returns the difference of two int slices
+func Ints(a, b []int) []Change {
+	return Diff(len(a), len(b), &ints{a, b})
 }
 
-// Runes attaches diff.Interface methods to an array of two rune slices
-type Runes [2][]rune
+type ints struct{ a, b []int }
 
-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)
+func (d *ints) Equal(i, j int) bool { return d.a[i] == d.b[j] }
+
+// Runes returns the difference of two rune slices
+func Runes(a, b []rune) []Change {
+	return Diff(len(a), len(b), &runes{a, b})
 }
 
+type runes struct{ a, b []rune }
+
+func (d *runes) Equal(i, j int) bool { return d.a[i] == d.b[j] }
+
 // Diff returns the differences of data.
-func Diff(data Interface) []Change {
-	n := data.N()
-	m := data.M()
+// data.Equal is called repeatedly with 0<=i<n and 0<=j<m
+func Diff(n, m int, data Data) []Change {
 	c := &context{data: data}
 	if n > m {
 		c.flags = make([]byte, n)
@@ -74,7 +54,7 @@ type Change struct {
 }
 
 type context struct {
-	data  Interface
+	data  Data
 	flags []byte // element bits 1 delete, 2 insert
 	max   int
 	// forward and reverse d-path endpoint x components

diff_test.go

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

example_test.go

@@ -21,12 +21,6 @@ type MixedInput struct {
 	B []string
 }
 
-func (m *MixedInput) N() int {
-	return len(m.A)
-}
-func (m *MixedInput) M() int {
-	return len(m.B)
-}
 func (m *MixedInput) Equal(a, b int) bool {
 	return m.A[a] == names[m.B[b]]
 }
@@ -36,7 +30,7 @@ func ExampleInterface() {
 		[]int{1, 2, 3, 1, 2, 2, 1},
 		[]string{"three", "two", "one", "two", "one", "three"},
 	}
-	changes := diff.Diff(m)
+	changes := diff.Diff(len(m.A), len(m.B), m)
 	for _, c := range changes {
 		fmt.Println("change at", c.A, c.B)
 	}