code review 5430046: strings: Add ContainsAny and ContainsRune to correspond...

src/pkg/strings/strings.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.
 
 // Package strings implements simple functions to manipulate strings.
 package strings
 
 import (
         "unicode"
         "unicode/utf8"
@@ skipping 46 matching lines @@
                 if s[i] == c && s[i:i+l] == sep {
                         n++
                         i += l - 1
                 }
         }
         return n
 }
 
 // Contains returns true if substr is within s.
 func Contains(s, substr string) bool {
-        return Index(s, substr) != -1
+        return Index(s, substr) >= 0
 }
 
 // ContainsAny returns true if any Unicode code points in chars are within s.
 func ContainsAny(s, chars string) bool {
-        return IndexAny(s, chars) != -1
-}
-
-// ContainsFunc returns true if any unicode code points within s satisfy f(c).
-func ContainsFunc(s string, f func(rune) bool) bool {
-        return IndexFunc(s, f) != -1
+        return IndexAny(s, chars) >= 0
 }
 
 // ContainsRune returns true if the Unicode code point r is within s.
 func ContainsRune(s string, r rune) bool {
-        return IndexRune(s, r) != -1
+        return IndexRune(s, r) >= 0
 }
 
 // Index returns the index of the first instance of sep in s, or -1 if sep is not present in s.
 func Index(s, sep string) int {
         n := len(sep)
         if n == 0 {
                 return 0
         }
         c := sep[0]
         if n == 1 {
@@ skipping 184 matching lines @@
                 if f(rune) {
                         if fieldStart >= 0 {
                                 a[na] = s[fieldStart:i]
                                 na++
                                 fieldStart = -1
                         }
                 } else if fieldStart == -1 {
                         fieldStart = i
                 }
         }
-        if fieldStart != -1 { // Last field might end at EOF.
+        if fieldStart >= 0 { // Last field might end at EOF.
                 a[na] = s[fieldStart:]
         }
         return a
 }
 
 // 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 {
         if len(a) == 0 {
                 return ""
@@ skipping 222 matching lines @@
                 r, size := utf8.DecodeLastRuneInString(s[0:i])
                 i -= size
                 if f(r) == truth {
                         return i
                 }
         }
         return -1
 }
 
 func makeCutsetFunc(cutset string) func(rune) bool {
-        return func(r rune) bool { return IndexRune(cutset, r) != -1 }
+        return func(r rune) bool { return IndexRune(cutset, r) >= 0 }
 }
 
 // Trim returns a slice of the string s with all leading and
 // trailing Unicode code points contained in cutset removed.
 func Trim(s string, cutset string) string {
         if s == "" || cutset == "" {
                 return s
         }
         return TrimFunc(s, makeCutsetFunc(cutset))
 }
@@ skipping 106 matching lines @@
                 }
                 if r == tr {
                         continue
                 }
                 return false
         }
 
         // One string is empty.  Are both?
         return s == t
 }