# Trait alloc::str::pattern::Pattern
[−][src]

    pub trait Pattern<'a> {
        type Searcher: Searcher<'a>;
        pub fn into_searcher(self, haystack: &'a str) -> Self::Searcher;

        pub fn is_contained_in(self, haystack: &'a str) -> bool { ... }
        pub fn is_prefix_of(self, haystack: &'a str) -> bool { ... }
        pub fn is_suffix_of(self, haystack: &'a str) -> bool
        where
            Self::Searcher: ReverseSearcher<'a>,
        { ... }
        pub fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> { ... }
        pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
        where
            Self::Searcher: ReverseSearcher<'a>,
        { ... }
    }

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

API not fully fleshed out and ready to be stabilized

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

Run

## Associated Types

### `type Searcher: Searcher<'a>`[src]

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

API not fully fleshed out and ready to be stabilized

Associated searcher for this pattern

Loading content...

## Required methods

### `pub fn into_searcher(self, haystack: &'a str) -> Self::Searcher`[src]

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

API not fully fleshed out and ready to be stabilized

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

Loading content...

## Provided methods

### `pub fn is_contained_in(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

Checks whether the pattern matches anywhere in the haystack

### `pub fn is_prefix_of(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

Checks whether the pattern matches at the front of the haystack

### `pub fn is_suffix_of(self, haystack: &'a str) -> bool where
Self::Searcher: ReverseSearcher<'a>,` [src]

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

API not fully fleshed out and ready to be stabilized

Checks whether the pattern matches at the back of the haystack

### `pub fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>`[src]

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

API not fully fleshed out and ready to be stabilized

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

### `pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
Self::Searcher: ReverseSearcher<'a>,` [src]

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

API not fully fleshed out and ready to be stabilized

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

Loading content...

## Implementors

### `impl<'a> Pattern<'a> for char`[src]

Searches for chars that are equal to a given `char`.

# Examples

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

Run

#### `type Searcher = CharSearcher<'a>`

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_contained_in(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_prefix_of(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>`[src]

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

### `impl<'a, 'b> Pattern<'a> for &'b String`[src]

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

# Examples

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

Run

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

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

API not fully fleshed out and ready to be stabilized

#### `fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher`[src]

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

API not fully fleshed out and ready to be stabilized

#### `fn is_contained_in(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `fn is_prefix_of(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>`[src]

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

API not fully fleshed out and ready to be stabilized

#### `fn is_suffix_of(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>`[src]

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

API not fully fleshed out and ready to be stabilized

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

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

# Examples

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

Run

#### `type Searcher = CharSliceSearcher<'a, 'b>`

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

API not fully fleshed out and ready to be stabilized

#### `pub fn into_searcher(self, haystack: &'a str) -> CharSliceSearcher<'a, 'b>`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_contained_in(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_prefix_of(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>`[src]

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

### `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.

# Examples

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

Run

#### `type Searcher = StrSearcher<'a, 'b>`

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

API not fully fleshed out and ready to be stabilized

#### `pub fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_prefix_of(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

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

#### `pub fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>`[src]

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

API not fully fleshed out and ready to be stabilized

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

#### `pub fn is_suffix_of(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

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

#### `pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>`[src]

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

API not fully fleshed out and ready to be stabilized

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

### `impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str`[src]

Delegates to the `&str` impl.

#### `type Searcher = StrSearcher<'a, 'b>`

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

API not fully fleshed out and ready to be stabilized

#### `pub fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_contained_in(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_prefix_of(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>`[src]

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

### `impl<'a, F> Pattern<'a> for F where
F: FnMut(char) -> bool,` [src]

Searches for `char`s 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));

Run

#### `type Searcher = CharPredicateSearcher<'a, F>`

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

API not fully fleshed out and ready to be stabilized

#### `pub fn into_searcher(self, haystack: &'a str) -> CharPredicateSearcher<'a, F>`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_contained_in(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_prefix_of(self, haystack: &'a str) -> bool`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>`[src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn is_suffix_of(self, haystack: &'a str) -> bool where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,` [src]

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

API not fully fleshed out and ready to be stabilized

#### `pub fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str> where
CharPredicateSearcher<'a, F>: ReverseSearcher<'a>,` [src]

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

API not fully fleshed out and ready to be stabilized

Loading content...