Trait Pattern

pub trait Pattern: Sized

A string pattern.

A Pattern expresses that the implementing type can be used as a string pattern for searching in a [&str][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 behavior of methods like str::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);

Associated Types

type Searcher<'a>: Searcher<'a>;

Associated searcher for this pattern

Required Methods

fn into_searcher(self, haystack: &str) -> Self::Searcher<'_>

Constructs the associated searcher from self and the haystack to search in.

Provided Methods

fn is_contained_in(self, haystack: &str) -> bool

Checks whether the pattern matches anywhere in the haystack

fn is_prefix_of(self, haystack: &str) -> bool

Checks whether the pattern matches at the front of the haystack

fn is_suffix_of<'a>(self, haystack: &'a str) -> bool
where
    Self::Searcher<'a>: ReverseSearcher<'a>,

Checks whether the pattern matches at the back of the haystack

fn strip_prefix_of(self, haystack: &str) -> Option<&str>

Removes the pattern from the front of haystack, if it matches.

fn strip_suffix_of<'a>(self, haystack: &'a str) -> Option<&'a str>
where
    Self::Searcher<'a>: ReverseSearcher<'a>,

Removes the pattern from the back of haystack, if it matches.

fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>>

Returns the pattern as UTF-8 if possible.

Implementors