Pattern in core::str::pattern - Rust (original) (raw)
pub trait Pattern: Sized {
type Searcher<'a>: Searcher<'a>;
// Required method
fn into_searcher(self, haystack: &str) -> Self::Searcher<'_>;
// Provided methods
fn is_contained_in(self, haystack: &str) -> bool { ... }
fn is_prefix_of(self, haystack: &str) -> bool { ... }
fn is_suffix_of<'a>(self, haystack: &'a str) -> bool
where Self::Searcher<'a>: ReverseSearcher<'a> { ... }
fn strip_prefix_of(self, haystack: &str) -> Option<&str> { ... }
fn strip_suffix_of<'a>(self, haystack: &'a str) -> Option<&'a str>
where Self::Searcher<'a>: ReverseSearcher<'a> { ... }
fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>> { ... }
}🔬This is a nightly-only experimental API. (pattern #27721)
Expand description
A string pattern.
A Pattern expresses that the implementing type can be used as a string pattern for searching in a &str.
For example, both 'a' and "aa" are patterns that would match at index 1 in the string "baaaab".
The trait itself acts as a builder for an associatedSearcher type, which does the actual work of finding occurrences of the pattern in a string.
Depending on the type of the pattern, the behavior of methods likestr::find and str::contains can change. The table below describes some of those behaviors.
| Pattern type | Match condition |
|---|---|
| &str | is substring |
| char | is contained in string |
| &[char] | any char in slice is contained in string |
| F: FnMut(char) -> bool | F returns true for a char in string |
| &&str | is substring |
| &String | is substring |
§Examples
// &str
assert_eq!("abaaa".find("ba"), Some(1));
assert_eq!("abaaa".find("bac"), None);
// char
assert_eq!("abaaa".find('a'), Some(0));
assert_eq!("abaaa".find('b'), Some(1));
assert_eq!("abaaa".find('c'), None);
// &[char; N]
assert_eq!("ab".find(&['b', 'a']), Some(0));
assert_eq!("abaaa".find(&['a', 'z']), Some(0));
assert_eq!("abaaa".find(&['c', 'd']), None);
// &[char]
assert_eq!("ab".find(&['b', 'a'][..]), Some(0));
assert_eq!("abaaa".find(&['a', 'z'][..]), Some(0));
assert_eq!("abaaa".find(&['c', 'd'][..]), None);
// FnMut(char) -> bool
assert_eq!("abcdef_z".find(|ch| ch > 'd' && ch < 'y'), Some(4));
assert_eq!("abcddd_z".find(|ch| ch > 'd' && ch < 'y'), None);🔬This is a nightly-only experimental API. (pattern #27721)
Associated searcher for this pattern
🔬This is a nightly-only experimental API. (pattern #27721)
Constructs the associated searcher fromself and the haystack to search in.
🔬This is a nightly-only experimental API. (pattern #27721)
Checks whether the pattern matches anywhere in the haystack
🔬This is a nightly-only experimental API. (pattern #27721)
Checks whether the pattern matches at the front of the haystack
🔬This is a nightly-only experimental API. (pattern #27721)
Checks whether the pattern matches at the back of the haystack
🔬This is a nightly-only experimental API. (pattern #27721)
Removes the pattern from the front of haystack, if it matches.
🔬This is a nightly-only experimental API. (pattern #27721)
Removes the pattern from the back of haystack, if it matches.
🔬This is a nightly-only experimental API. (pattern #27721)
Returns the pattern as utf-8 bytes if possible.
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.
Searches for chars that are equal to a given char.
§Examples
assert_eq!("Hello world".find('o'), Some(4));Non-allocating substring search.
Will handle the pattern "" as returning empty matches at each character boundary.
§Examples
assert_eq!("Hello world".find("world"), Some(6));Searches for chars that are equal to any of the chars in the slice.
§Examples
assert_eq!("Hello world".find(&['o', 'l'][..]), Some(2));
assert_eq!("Hello world".find(&['h', 'w'][..]), Some(6));Delegates to the &str impl.
Searches for chars that are equal to any of the chars in the array.
§Examples
assert_eq!("Hello world".find(&['o', 'l']), Some(2));
assert_eq!("Hello world".find(&['h', 'w']), Some(6));Searches for chars that match the given predicate.
§Examples
assert_eq!("Hello world".find(char::is_uppercase), Some(0));
assert_eq!("Hello world".find(|c| "aeiou".contains(c)), Some(1));Searches for chars that are equal to any of the chars in the array.
§Examples
assert_eq!("Hello world".find(['o', 'l']), Some(2));
assert_eq!("Hello world".find(['h', 'w']), Some(6));