pub trait Pattern<'a> {
type Searcher: Searcher<'a>;
fn into_searcher(self, haystack: &'a str) -> Self::Searcher;
fn is_contained_in(self, haystack: &'a str) -> bool { ... }
fn is_prefix_of(self, haystack: &'a str) -> bool { ... }
fn is_suffix_of(self, haystack: &'a str) -> bool where Self::Searcher: ReverseSearcher<'a>,
{ ... }
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> { ... }
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where Self::Searcher: ReverseSearcher<'a>,
{ ... }
}
A string pattern.
A Pattern<'a> expresses that the implementing type can be used as a string pattern for searching in a &'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 associated Searcher type, which does the actual work of finding occurrences of the pattern in a string.
Depending on the type of the pattern, the behaviour of methods like str::find and str::contains can change. The table below describes some of those behaviours.
| 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 |
// &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]
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);type Searcher: Searcher<'a>Associated searcher for this pattern
fn into_searcher(self, haystack: &'a str) -> Self::SearcherConstructs the associated searcher from self and the haystack to search in.
fn is_contained_in(self, haystack: &'a str) -> boolChecks whether the pattern matches anywhere in the haystack
fn is_prefix_of(self, haystack: &'a str) -> boolChecks whether the pattern matches at the front of the haystack
fn is_suffix_of(self, haystack: &'a str) -> bool where
Self::Searcher: ReverseSearcher<'a>, Checks whether the pattern matches at the back of the haystack
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>Removes the pattern from the front of haystack, if it matches.
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
Self::Searcher: ReverseSearcher<'a>, Removes the pattern from the back of haystack, if it matches.
impl<'a> Pattern<'a> for char[src]
Searches for chars that are equal to a given char.
assert_eq!("Hello world".find('o'), Some(4));type Searcher = CharSearcher<'a>fn into_searcher(self, haystack: &'a str) -> <char as Pattern<'a>>::Searcher[src]
fn is_contained_in(self, haystack: &'a str) -> bool[src]
fn is_prefix_of(self, haystack: &'a str) -> bool[src]
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>[src]
fn is_suffix_of(self, haystack: &'a str) -> bool where
<char as Pattern<'a>>::Searcher: ReverseSearcher<'a>, [src]
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
<char as Pattern<'a>>::Searcher: ReverseSearcher<'a>, [src]
impl<'a, 'b> Pattern<'a> for &'b str[src]
Non-allocating substring search.
Will handle the pattern "" as returning empty matches at each character boundary.
assert_eq!("Hello world".find("world"), Some(6));type Searcher = StrSearcher<'a, 'b>fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>[src]
fn is_prefix_of(self, haystack: &'a str) -> bool[src]
Checks whether the pattern matches at the front of the haystack.
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>[src]
Removes the pattern from the front of haystack, if it matches.
fn is_suffix_of(self, haystack: &'a str) -> bool[src]
Checks whether the pattern matches at the back of the haystack.
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>[src]
Removes the pattern from the back of haystack, if it matches.
impl<'a, 'b> Pattern<'a> for &'b String[src]
A convenience impl that delegates to the impl for &str.
assert_eq!(String::from("Hello world").find("world"), Some(6));type Searcher = <&'b str as Pattern<'a>>::Searcherfn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher[src]
fn is_contained_in(self, haystack: &'a str) -> bool[src]
fn is_prefix_of(self, haystack: &'a str) -> bool[src]
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>[src]
fn is_suffix_of(self, haystack: &'a str) -> bool[src]
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>[src]
impl<'a, 'b> Pattern<'a> for &'b [char][src]
Searches for chars that are equal to any of the chars in the slice.
assert_eq!("Hello world".find(&['l', 'l'] as &[_]), Some(2));
assert_eq!("Hello world".find(&['l', 'l'][..]), Some(2));type Searcher = CharSliceSearcher<'a, 'b>fn into_searcher(self, haystack: &'a str) -> CharSliceSearcher<'a, 'b>[src]
fn is_contained_in(self, haystack: &'a str) -> bool[src]
fn is_prefix_of(self, haystack: &'a str) -> bool[src]
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>[src]
fn is_suffix_of(self, haystack: &'a str) -> bool where
CharSliceSearcher<'a, 'b>: ReverseSearcher<'a>, [src]
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
CharSliceSearcher<'a, 'b>: ReverseSearcher<'a>, [src]
impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str[src]
Delegates to the &str impl.
type Searcher = StrSearcher<'a, 'b>fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>[src]
fn is_contained_in(self, haystack: &'a str) -> bool[src]
fn is_prefix_of(self, haystack: &'a str) -> bool[src]
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>[src]
fn is_suffix_of(self, haystack: &'a str) -> bool where
StrSearcher<'a, 'b>: ReverseSearcher<'a>, [src]
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
StrSearcher<'a, 'b>: ReverseSearcher<'a>, [src]
impl<'a, F> Pattern<'a> for F where
F: FnMut(char) -> bool, [src]
Searches for chars that match the given predicate.
assert_eq!("Hello world".find(char::is_uppercase), Some(0));
assert_eq!("Hello world".find(|c| "aeiou".contains(c)), Some(1));type Searcher = CharPredicateSearcher<'a, F>fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>[src]
fn is_contained_in(self, haystack: &'a str) -> bool[src]
fn is_prefix_of(self, haystack: &'a str) -> bool[src]
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>[src]
fn is_suffix_of(self, haystack: &'a str) -> bool where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>, [src]
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>, [src]
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/str/pattern/trait.Pattern.html