code review 1696062: bytes: add IndexRune, FieldsFunc and To*Special

src/pkg/bytes/bytes.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // The bytes package implements functions for the manipulation of byte slices.
 // Analogous to the facilities of the strings package.
 package bytes
 
 import (
         "unicode"
@@ skipping 110 matching lines @@
         c := sep[0]
         for i := len(s) - n; i >= 0; i-- {
                 if s[i] == c && (n == 1 || Equal(s[i:i+n], sep)) {
                         return i
                 }
         }
         return -1
 }
 
 // IndexRune interprets s as a sequence of UTF-8-encoded Unicode code points.
-// It returns the byte index of the first occurrence in s of the Unicode code

[r, 2010/08/05 12:55:07]

You can just say

of the given rune.

The context is clear by now.

-// point rune.  It returns -1 if rune is not present in s.
+// It returns the byte index of the first occurrence in s of the given rune.
+// It returns -1 if rune is not present in s.
 func IndexRune(s []byte, rune int) int {
         for i := 0; i < len(s); {
                 r, size := utf8.DecodeRune(s[i:])
                 if r == rune {
                         return i
                 }
                 i += size
         }
         return -1
 }
@@ skipping 70 matching lines @@
         return genSplit(s, sep, len(sep), n)
 }
 
 // Fields splits the array s around each instance of one or more consecutive white space
 // characters, returning a slice of subarrays of s or an empty list if s contains only white space.
 func Fields(s []byte) [][]byte {
         return FieldsFunc(s, unicode.IsSpace)
 }
 
 // FieldsFunc interprets s as a sequence of UTF-8-encoded Unicode code points.
-// It splits the array s at each run of Unicode code points c satisfying f(c)

[r, 2010/08/05 12:55:07]

s/Unicode code points/code points/

-// and returns a slice of subarrays of s.  If no code points in s satisfy f(c),
-// an empty slice is returned.
+// It splits the array s at each run of code points c satisfying f(c) and
+// returns a slice of subarrays of s.  If no code points in s satisfy f(c), an
+// empty slice is returned.
 func FieldsFunc(s []byte, f func(int) bool) [][]byte {
         n := 0
         inField := false
         for i := 0; i < len(s); {
                 rune, size := utf8.DecodeRune(s[i:])
                 wasInField := inField
                 inField = !f(rune)
                 if inField && !wasInField {
                         n++
                 }
@@ skipping 404 matching lines @@
                 } else {
                         j += Index(s[start:], old)
                 }
                 w += copy(t[w:], s[start:j])
                 w += copy(t[w:], new)
                 start = j + len(old)
         }
         w += copy(t[w:], s[start:])
         return t[0:w]
 }