bytes.SplitAfter and strings.SplitAfter

most common usage is:

	lines := strings.SplitAfter(text, "\n", 0)

R=r
http://go/go-review/1018042

2 files changed, 48 insertions, 5 deletions

diff --git a/src/pkg/strings/strings.go b/src/pkg/strings/strings.go
index f4b969b42b..ecfb088cd9 100644
--- a/src/pkg/strings/strings.go
+++ b/src/pkg/strings/strings.go
@@ -79,10 +79,9 @@ func LastIndex(s, sep string) int {
 	return -1
 }
 
-// Split splits the string s around each instance of sep, returning an array of substrings of s.
-// If sep is empty, Split splits s after each UTF-8 sequence.
-// If n > 0, split Splits s into at most n substrings; the last subarray will contain an unsplit remainder string.
-func Split(s, sep string, n int) []string {
+// Generic split: splits after each instance of sep,
+// including sepSave bytes of sep in the subarrays.
+func genSplit(s, sep string, sepSave, n int) []string {
 	if sep == "" {
 		return explode(s, n)
 	}
@@ -95,7 +94,7 @@ func Split(s, sep string, n int) []string {
 	na := 0;
 	for i := 0; i+len(sep) <= len(s) && na+1 < n; i++ {
 		if s[i] == c && (len(sep) == 1 || s[i:i+len(sep)] == sep) {
-			a[na] = s[start:i];
+			a[na] = s[start:i+sepSave];
 			na++;
 			start = i+len(sep);
 			i += len(sep)-1;
@@ -105,6 +104,20 @@ func Split(s, sep string, n int) []string {
 	return a[0:na+1]
 }
 
+// Split splits the string s around each instance of sep, returning an array of substrings of s.
+// If sep is empty, Split splits s after each UTF-8 sequence.
+// If n > 0, split Splits s into at most n substrings; the last substring will be the unsplit remainder.
+func Split(s, sep string, n int) []string {
+	return genSplit(s, sep, 0, n);
+}
+
+// SplitAfter splits the string s after each instance of sep, returning an array of substrings of s.
+// If sep is empty, SplitAfter splits s after each UTF-8 sequence.
+// If n > 0, SplitAfter splits s into at most n substrings; the last substring will be the unsplit remainder.
+func SplitAfter(s, sep string, n int) []string {
+	return genSplit(s, sep, len(sep), n);
+}
+
 // Join concatenates the elements of a to create a single string.   The separator string
 // sep is placed between elements in the resulting string.
 func Join(a []string, sep string) string {
diff --git a/src/pkg/strings/strings_test.go b/src/pkg/strings/strings_test.go
index bdc7f9f081..0db3c97416 100644
--- a/src/pkg/strings/strings_test.go
+++ b/src/pkg/strings/strings_test.go
@@ -145,6 +145,36 @@ func TestSplit(t *testing.T) {
 	}
 }
 
+var splitaftertests = []SplitTest{
+	SplitTest{abcd, "a", 0, []string{"a", "bcd"}},
+	SplitTest{abcd, "z", 0, []string{"abcd"}},
+	SplitTest{abcd, "", 0, []string{"a", "b", "c", "d"}},
+	SplitTest{commas, ",", 0, []string{"1,", "2,", "3,", "4"}},
+	SplitTest{dots, "...", 0, []string{"1...", ".2...", ".3...", ".4"}},
+	SplitTest{faces, "☹", 0, []string{"☺☻☹", ""}},
+	SplitTest{faces, "~", 0, []string{faces}},
+	SplitTest{faces, "", 0, []string{"☺", "☻", "☹"}},
+	SplitTest{"1 2 3 4", " ", 3, []string{"1 ", "2 ", "3 4"}},
+	SplitTest{"1 2 3", " ", 3, []string{"1 ", "2 ", "3"}},
+	SplitTest{"1 2", " ", 3, []string{"1 ", "2"}},
+	SplitTest{"123", "", 2, []string{"1", "23"}},
+	SplitTest{"123", "", 17, []string{"1", "2", "3"}},
+}
+
+func TestSplitAfter(t *testing.T) {
+	for _, tt := range splitaftertests {
+		a := SplitAfter(tt.s, tt.sep, tt.n);
+		if !eq(a, tt.a) {
+			t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, a, tt.a);
+			continue;
+		}
+		s := Join(a, "");
+		if s != tt.s {
+			t.Errorf(`Join(Split(%q, %q, %d), %q) = %q`, tt.s, tt.sep, tt.n, tt.sep, s);
+		}
+	}
+}
+
 // Test case for any function which accepts and returns a single string.
 type StringTest struct {
 	in, out string;