Rename {NDiff,NSame} as {NumDiff,NumSame} (#118)

2 files changed, 32 insertions, 32 deletions

diff --git a/cmp/internal/diff/diff.go b/cmp/internal/diff/diff.go
index 6326465..8179011 100644
--- a/cmp/internal/diff/diff.go
+++ b/cmp/internal/diff/diff.go
@@ -85,22 +85,22 @@ func (es EditScript) LenY() int { return len(es) - es.stats().NX }
 type EqualFunc func(ix int, iy int) Result
 
 // Result is the result of comparison.
-// NSame is the number of sub-elements that are equal.
-// NDiff is the number of sub-elements that are not equal.
-type Result struct{ NSame, NDiff int }
+// NumSame is the number of sub-elements that are equal.
+// NumDiff is the number of sub-elements that are not equal.
+type Result struct{ NumSame, NumDiff int }
 
 // Equal indicates whether the symbols are equal. Two symbols are equal
-// if and only if NDiff == 0. If Equal, then they are also Similar.
-func (r Result) Equal() bool { return r.NDiff == 0 }
+// if and only if NumDiff == 0. If Equal, then they are also Similar.
+func (r Result) Equal() bool { return r.NumDiff == 0 }
 
 // Similar indicates whether two symbols are similar and may be represented
 // by using the Modified type. As a special case, we consider binary comparisons
 // (i.e., those that return Result{1, 0} or Result{0, 1}) to be similar.
 //
-// The exact ratio of NSame to NDiff to determine similarity may change.
+// The exact ratio of NumSame to NumDiff to determine similarity may change.
 func (r Result) Similar() bool {
-	// Use NSame+1 to offset NSame so that binary comparisons are similar.
-	return r.NSame+1 >= r.NDiff
+	// Use NumSame+1 to offset NumSame so that binary comparisons are similar.
+	return r.NumSame+1 >= r.NumDiff
 }
 
 // Difference reports whether two lists of lengths nx and ny are equal
diff --git a/cmp/internal/diff/diff_test.go b/cmp/internal/diff/diff_test.go
index 0752f4a..ef39077 100644
--- a/cmp/internal/diff/diff_test.go
+++ b/cmp/internal/diff/diff_test.go
@@ -387,9 +387,9 @@ func compareByte(x, y byte) (r Result) {
 }
 
 var (
-	equalResult     = Result{NDiff: 0}
-	similarResult   = Result{NDiff: 1}
-	differentResult = Result{NDiff: 2}
+	equalResult     = Result{NumDiff: 0}
+	similarResult   = Result{NumDiff: 1}
+	differentResult = Result{NumDiff: 2}
 )
 
 func TestResult(t *testing.T) {
@@ -398,39 +398,39 @@ func TestResult(t *testing.T) {
 		wantEqual   bool
 		wantSimilar bool
 	}{
-		// equalResult is equal since NDiff == 0, by definition of Equal method.
+		// equalResult is equal since NumDiff == 0, by definition of Equal method.
 		{equalResult, true, true},
 		// similarResult is similar since it is a binary result where only one
-		// element was compared (i.e., Either NSame==1 or NDiff==1).
+		// element was compared (i.e., Either NumSame==1 or NumDiff==1).
 		{similarResult, false, true},
 		// differentResult is different since there are enough differences that
 		// it isn't even considered similar.
 		{differentResult, false, false},
 
 		// Zero value is always equal.
-		{Result{NSame: 0, NDiff: 0}, true, true},
+		{Result{NumSame: 0, NumDiff: 0}, true, true},
 
-		// Binary comparisons (where NSame+NDiff == 1) are always similar.
-		{Result{NSame: 1, NDiff: 0}, true, true},
-		{Result{NSame: 0, NDiff: 1}, false, true},
+		// Binary comparisons (where NumSame+NumDiff == 1) are always similar.
+		{Result{NumSame: 1, NumDiff: 0}, true, true},
+		{Result{NumSame: 0, NumDiff: 1}, false, true},
 
 		// More complex ratios. The exact ratio for similarity may change,
 		// and may require updates to these test cases.
-		{Result{NSame: 1, NDiff: 1}, false, true},
-		{Result{NSame: 1, NDiff: 2}, false, true},
-		{Result{NSame: 1, NDiff: 3}, false, false},
-		{Result{NSame: 2, NDiff: 1}, false, true},
-		{Result{NSame: 2, NDiff: 2}, false, true},
-		{Result{NSame: 2, NDiff: 3}, false, true},
-		{Result{NSame: 3, NDiff: 1}, false, true},
-		{Result{NSame: 3, NDiff: 2}, false, true},
-		{Result{NSame: 3, NDiff: 3}, false, true},
-		{Result{NSame: 1000, NDiff: 0}, true, true},
-		{Result{NSame: 1000, NDiff: 1}, false, true},
-		{Result{NSame: 1000, NDiff: 2}, false, true},
-		{Result{NSame: 0, NDiff: 1000}, false, false},
-		{Result{NSame: 1, NDiff: 1000}, false, false},
-		{Result{NSame: 2, NDiff: 1000}, false, false},
+		{Result{NumSame: 1, NumDiff: 1}, false, true},
+		{Result{NumSame: 1, NumDiff: 2}, false, true},
+		{Result{NumSame: 1, NumDiff: 3}, false, false},
+		{Result{NumSame: 2, NumDiff: 1}, false, true},
+		{Result{NumSame: 2, NumDiff: 2}, false, true},
+		{Result{NumSame: 2, NumDiff: 3}, false, true},
+		{Result{NumSame: 3, NumDiff: 1}, false, true},
+		{Result{NumSame: 3, NumDiff: 2}, false, true},
+		{Result{NumSame: 3, NumDiff: 3}, false, true},
+		{Result{NumSame: 1000, NumDiff: 0}, true, true},
+		{Result{NumSame: 1000, NumDiff: 1}, false, true},
+		{Result{NumSame: 1000, NumDiff: 2}, false, true},
+		{Result{NumSame: 0, NumDiff: 1000}, false, false},
+		{Result{NumSame: 1, NumDiff: 1000}, false, false},
+		{Result{NumSame: 2, NumDiff: 1000}, false, false},
 	}
 
 	for _, tt := range tests {