Trait sp_std::str::pattern::Pattern

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>,
    { ... }
}

🔬 This is a nightly-only experimental API. (pattern)

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; 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: Searcher<'a>

🔬 This is a nightly-only experimental API. (pattern)

Associated searcher for this pattern

Required methods

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

🔬 This is a nightly-only experimental API. (pattern)

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

Provided methods

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

🔬 This is a nightly-only experimental API. (pattern)

Checks whether the pattern matches anywhere in the haystack

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

🔬 This is a nightly-only experimental API. (pattern)

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>, 

🔬 This is a nightly-only experimental API. (pattern)

Checks whether the pattern matches at the back of the haystack

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

🔬 This is a nightly-only experimental API. (pattern)

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>, 

🔬 This is a nightly-only experimental API. (pattern)

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

Implementations on Foreign Types

impl<'a, 'b, const N: usize> Pattern<'a> for &'b [char; N]

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

Examples

assert_eq!("Hello world".find(&['l', 'l']), Some(2));
assert_eq!("Hello world".find(&['l', 'l']), Some(2));

type Searcher = CharArrayRefSearcher<'a, 'b, N>

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

pub fn is_suffix_of(self, haystack: &'a str) -> bool where
    CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
    CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

impl<'a, const N: usize> Pattern<'a> for [char; N]

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

Examples

assert_eq!("Hello world".find(['l', 'l']), Some(2));
assert_eq!("Hello world".find(['l', 'l']), Some(2));

type Searcher = CharArraySearcher<'a, N>

🔬 This is a nightly-only experimental API. (pattern)

pub fn into_searcher(self, haystack: &'a str) -> CharArraySearcher<'a, N>

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

pub fn is_suffix_of(self, haystack: &'a str) -> bool where
    CharArraySearcher<'a, N>: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
    CharArraySearcher<'a, N>: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

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

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

🔬 This is a nightly-only experimental API. (pattern)

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

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

🔬 This is a nightly-only experimental API. (pattern)

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

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

🔬 This is a nightly-only experimental API. (pattern)

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

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

🔬 This is a nightly-only experimental API. (pattern)

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

type Searcher = StrSearcher<'a, 'b>

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

Delegates to the &str impl.

type Searcher = StrSearcher<'a, 'b>

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

pub fn is_suffix_of(self, haystack: &'a str) -> bool where
    StrSearcher<'a, 'b>: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
    StrSearcher<'a, 'b>: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

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>

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

pub fn is_suffix_of(self, haystack: &'a str) -> bool where
    CharSliceSearcher<'a, 'b>: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
    CharSliceSearcher<'a, 'b>: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

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>

🔬 This is a nightly-only experimental API. (pattern)

pub fn into_searcher(self, haystack: &'a str) -> <char as Pattern<'a>>::Searcher

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

pub fn is_suffix_of(self, haystack: &'a str) -> bool where
    <char as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
    <char as Pattern<'a>>::Searcher: ReverseSearcher<'a>, 

🔬 This is a nightly-only experimental API. (pattern)

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

A convenience impl that delegates to the impl for &str.

Examples

assert_eq!(String::from("Hello world").find("world"), Some(6));

type Searcher = <&'b str as Pattern<'a>>::Searcher

🔬 This is a nightly-only experimental API. (pattern)

pub fn into_searcher(
    self,
    haystack: &'a str
) -> <&'b str as Pattern<'a>>::Searcher

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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

🔬 This is a nightly-only experimental API. (pattern)

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>