bytes, strings: add ContainsFunc

Fixes #54386.

Change-Id: I78747da337ed6129e4f7426dd0483a644bed82e3
Reviewed-on: https://go-review.googlesource.com/c/go/+/460216
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Ian Lance Taylor <iant@google.com>
Run-TryBot: hopehook <hopehook@golangcn.org>
Auto-Submit: Ian Lance Taylor <iant@golang.org>

diff --git a/api/next/54386.txt b/api/next/54386.txt
new file mode 100644 (file)
index 0000000..742751e
--- /dev/null
+++ b/api/next/54386.txt
@@ -0,0 +1,2 @@
+pkg bytes, func ContainsFunc([]uint8, func(int32) bool) bool #54386
+pkg strings, func ContainsFunc(string, func(int32) bool) bool #54386

diff --git a/src/bytes/bytes.go b/src/bytes/bytes.go
index e2e5d5fda757983cf50b26d459d81e48e879263c..ea8146c166a425c601368fdac100fc657a626f50 100644 (file)
--- a/src/bytes/bytes.go
+++ b/src/bytes/bytes.go
@@ -86,6 +86,11 @@ func ContainsRune(b []byte, r rune) bool {
        return IndexRune(b, r) >= 0
 }
 
+// ContainsFunc reports whether any of the UTF-8-encoded code points r within b satisfy f(r).
+func ContainsFunc(b []byte, f func(rune) bool) bool {
+       return IndexFunc(b, f) >= 0
+}
+
 // IndexByte returns the index of the first instance of c in b, or -1 if c is not present in b.
 func IndexByte(b []byte, c byte) int {
        return bytealg.IndexByte(b, c)

diff --git a/src/bytes/bytes_test.go b/src/bytes/bytes_test.go
index fc2824485aae85ddb344bc9eab61df39393b16c1..05c0090b6173fe3e58819836b4acbd66c9ee00cf 100644 (file)
--- a/src/bytes/bytes_test.go
+++ b/src/bytes/bytes_test.go
@@ -1847,6 +1847,17 @@ func TestContainsRune(t *testing.T) {
        }
 }
 
+func TestContainsFunc(t *testing.T) {
+       for _, ct := range ContainsRuneTests {
+               if ContainsFunc(ct.b, func(r rune) bool {
+                       return ct.r == r
+               }) != ct.expected {
+                       t.Errorf("ContainsFunc(%q, func(%q)) = %v, want %v",
+                               ct.b, ct.r, !ct.expected, ct.expected)
+               }
+       }
+}
+
 var makeFieldsInput = func() []byte {
        x := make([]byte, 1<<20)
        // Input is ~10% space, ~10% 2-byte UTF-8, rest ASCII non-space.

diff --git a/src/strings/strings.go b/src/strings/strings.go
index 646161fdda72ac302c7305518d918c26dc72690d..3f7d6fd1a2b832c60f6794079dea931394ed55bc 100644 (file)
--- a/src/strings/strings.go
+++ b/src/strings/strings.go
@@ -69,6 +69,11 @@ func ContainsRune(s string, r rune) bool {
        return IndexRune(s, r) >= 0
 }
 
+// ContainsFunc reports whether any Unicode code points r within s satisfy f(r).
+func ContainsFunc(s string, f func(rune) bool) bool {
+       return IndexFunc(s, f) >= 0
+}
+
 // LastIndex returns the index of the last instance of substr in s, or -1 if substr is not present in s.
 func LastIndex(s, substr string) int {
        n := len(substr)

diff --git a/src/strings/strings_test.go b/src/strings/strings_test.go
index 5143ec86c958e7ce449a8b5e55b16b9aaaf90504..f93cf6842fb9ba6cfa0e1e6b5d9d75b6207b2509 100644 (file)
--- a/src/strings/strings_test.go
+++ b/src/strings/strings_test.go
@@ -1535,6 +1535,17 @@ func TestContainsRune(t *testing.T) {
        }
 }
 
+func TestContainsFunc(t *testing.T) {
+       for _, ct := range ContainsRuneTests {
+               if ContainsFunc(ct.str, func(r rune) bool {
+                       return ct.r == r
+               }) != ct.expected {
+                       t.Errorf("ContainsFunc(%q, func(%q)) = %v, want %v",
+                               ct.str, ct.r, !ct.expected, ct.expected)
+               }
+       }
+}
+
 var EqualFoldTests = []struct {
        s, t string
        out  bool