Trait Pattern

pub trait Pattern<'a>: Sized {
    type Searcher: Searcher<'a>;

    // Required method
    fn into_searcher(self, haystack: &'a str) -> Self::Searcher;

    // Provided methods
    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

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]
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);

Required Associated Types

type Searcher: Searcher<'a>

Associated searcher for this pattern

Required Methods

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

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

Provided Methods

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

Checks whether the pattern matches anywhere in the haystack

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

Checks 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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a> Pattern<'a> for char

Searches for chars that are equal to a given char.

Examples

assert_eq!("Hello world".find('o'), Some(4));

type Searcher = CharSearcher<'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 strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>

fn is_suffix_of(self, haystack: &'a str) -> bool

where Self::Searcher: ReverseSearcher<'a>,

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

where Self::Searcher: ReverseSearcher<'a>,

impl<'a, 'b> Pattern<'a> for &'b str

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));

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

Checks whether the pattern matches at the front 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 is_suffix_of(self, haystack: &'a str) -> bool

Checks whether the pattern matches at the back of the haystack.

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

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

type Searcher = StrSearcher<'a, 'b>

fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>

impl<'a, 'b> Pattern<'a> for &'b [char]

Searches for chars that are equal to any of the chars in the slice.

Examples

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>

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

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

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

fn is_suffix_of(self, haystack: &'a str) -> bool

where CharSliceSearcher<'a, 'b>: ReverseSearcher<'a>,

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

where CharSliceSearcher<'a, 'b>: ReverseSearcher<'a>,

impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str

Delegates to the &str impl.

type Searcher = StrSearcher<'a, 'b>

fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>

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

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

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

fn is_suffix_of(self, haystack: &'a str) -> bool

where StrSearcher<'a, 'b>: ReverseSearcher<'a>,

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

where StrSearcher<'a, 'b>: ReverseSearcher<'a>,

Implementors

impl<'a, F> Pattern<'a> for F

where F: FnMut(char) -> bool,

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));

type Searcher = CharPredicateSearcher<'a, F>