sort: fix mix-up between "!less" and "greater" in examples

If Less(a, b) returns true when a is less than b, the correct way to
check if a is greater than b is to use Less(b, a). It is wrong to use
!Less(a, b) because that checks if a is greater than *or equal to* b.

1. The decreasingDistance function in Example_sortKeys makes this
   mistake. Fix it.

2. The documentation of multiSorter.Less says it loops along the less
   functions until it finds a comparison "that is either Less or
   !Less". This is nonsense, because (Less(a, b) or !Less(a, b)) is
   always true. Fix the documentation to say that it finds a
   comparison "that discriminates between the two items (one is less
   than the other)". The implementation already does this correctly.

Change-Id: If52b79f68e4fdb0d1095edf29bdecdf154a61b8d
Reviewed-on: https://go-review.googlesource.com/57752
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

diff --git a/src/sort/example_keys_test.go b/src/sort/example_keys_test.go
index a8e47e4926b64742fc74fceb2b7b995b83b525b6..648f919e68dbd9d353d9fe2b52784b928ac8ec93 100644 (file)
--- a/src/sort/example_keys_test.go
+++ b/src/sort/example_keys_test.go
@@ -73,7 +73,7 @@ func Example_sortKeys() {
                return p1.distance < p2.distance
        }
        decreasingDistance := func(p1, p2 *Planet) bool {
-               return !distance(p1, p2)
+               return distance(p2, p1)
        }
 
        // Sort the planets by the various criteria.

diff --git a/src/sort/example_multi_test.go b/src/sort/example_multi_test.go
index 40d12152ce28c111af0d083a9a0b05320d6b8bd0..de6ec142d1c44ce616b35a79080924e6a8d4de1e 100644 (file)
--- a/src/sort/example_multi_test.go
+++ b/src/sort/example_multi_test.go
@@ -49,10 +49,11 @@ func (ms *multiSorter) Swap(i, j int) {
 }
 
 // Less is part of sort.Interface. It is implemented by looping along the
-// less functions until it finds a comparison that is either Less or
-// !Less. Note that it can call the less functions twice per call. We
-// could change the functions to return -1, 0, 1 and reduce the
-// number of calls for greater efficiency: an exercise for the reader.
+// less functions until it finds a comparison that discriminates between
+// the two items (one is less than the other). Note that it can call the
+// less functions twice per call. We could change the functions to return
+// -1, 0, 1 and reduce the number of calls for greater efficiency: an
+// exercise for the reader.
 func (ms *multiSorter) Less(i, j int) bool {
        p, q := &ms.changes[i], &ms.changes[j]
        // Try all but the last comparison.