From 0416f994b76c90d916d1e7d8409166139a38eefa Mon Sep 17 00:00:00 2001
From: Robert Griesemer <gri@golang.org>
Date: Tue, 9 Sep 2008 18:13:08 -0700
Subject: [PATCH] - added convenience wrappers for sort   (work now with Ken's
 latest compiler fix) - exoanded test cases accordingly - fixed a type in the
 spec (thx r)

R=r
DELTA=65  (62 added, 2 deleted, 1 changed)
OCL=15050
CL=15050
---
 doc/go_spec.txt |  2 +-
 src/lib/sort.go | 14 ++++++++++++--
 test/sorting.go | 50 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 63 insertions(+), 3 deletions(-)

diff --git a/doc/go_spec.txt b/doc/go_spec.txt
index 380dbbfaa3a..32eeaeea221 100644
--- a/doc/go_spec.txt
+++ b/doc/go_spec.txt
@@ -2269,7 +2269,7 @@ representation of the integer.
 5b) Converting an array of uint8s yields a string whose successive
 bytes are those of the array.  (Recall byte is a synonym for uint8.)
 
-	string([]byte('h', 'e', 'l', 'l', 'o')) // "hello"
+	string([]byte{'h', 'e', 'l', 'l', 'o'}) // "hello"
 
 Note that there is no linguistic mechanism to convert between pointers
 and integers. A library may be provided under restricted circumstances
diff --git a/src/lib/sort.go b/src/lib/sort.go
index 72b0ddd47a6..fb5f77f4711 100644
--- a/src/lib/sort.go
+++ b/src/lib/sort.go
@@ -65,8 +65,6 @@ export func IsSorted(data SortInterface) bool {
 
 
 // Convenience types for common cases
-// TODO: Once we can associate methods with all types, this can be simplified
-//       since we cann associate the methods with the arrays directly.
 
 export type IntArray struct {
 	data *[]int;
@@ -93,3 +91,15 @@ export type StringArray struct {
 func (p *StringArray) len() int            { return len(p.data); }
 func (p *StringArray) less(i, j int) bool  { return p.data[i] < p.data[j]; }
 func (p *StringArray) swap(i, j int)       { p.data[i], p.data[j] = p.data[j], p.data[i]; }
+
+
+// Convenience wrappers for common cases
+
+export func SortInts(a *[]int)        { Sort(&IntArray{a}); }
+export func SortFloats(a *[]float)    { Sort(&FloatArray{a}); }
+export func SortStrings(a *[]string)  { Sort(&StringArray{a}); }
+
+
+export func IntsAreSorted(a *[]int) bool       { return IsSorted(&IntArray{a}); }
+export func FloatsAreSorted(a *[]float) bool   { return IsSorted(&FloatArray{a}); }
+export func StringsAreSorted(a *[]string) bool { return IsSorted(&StringArray{a}); }
diff --git a/test/sorting.go b/test/sorting.go
index f55e9fddda4..ae9dafb7519 100644
--- a/test/sorting.go
+++ b/test/sorting.go
@@ -59,4 +59,54 @@ func main() {
 			panic();
 		}
 	}
+	
+	// Same tests again, this time using the convenience wrappers
+	
+	{	data := []int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586};
+		
+		Sort.SortInts(&data);
+
+		/*
+		for i := 0; i < len(data); i++ {
+			print(data[i], " ");
+		}
+		print("\n");
+		*/
+		
+		if !Sort.IntsAreSorted(&data) {
+			panic();
+		}
+	}
+
+	{	data := []float{74.3, 59.0, 238.2, -784.0, 2.3, 9845.768, -959.7485, 905, 7.8, 7.8};
+		
+		Sort.SortFloats(&data);
+
+		/*
+		for i := 0; i < len(data); i++ {
+			print(data[i], " ");
+		}
+		print("\n");
+		*/
+		
+		if !Sort.FloatsAreSorted(&data) {
+			panic();
+		}
+	}
+
+	{	data := []string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"};
+		
+		Sort.SortStrings(&data);
+
+		/*
+		for i := 0; i < len(data); i++ {
+			print(data[i], " ");
+		}
+		print("\n");
+		*/
+		
+		if !Sort.StringsAreSorted(&data) {
+			panic();
+		}
+	}
 }