Trait Pattern

pub trait Pattern {
    // Required methods
    fn immediate_match<I: Input>(&self, input: I) -> Result<(I, I), I>;
    fn trailing_match<I: Input>(&self, input: I) -> Result<(I, I), I>;
    fn first_match<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>;
    fn first_match_ex<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>;

    // Provided methods
    fn immediate_matches<I: Input>(&self, input: I) -> (I, I) { ... }
    fn immediate_matches_counted<I: Input>(&self, input: I) -> (I, (I, usize)) { ... }
    fn trailing_matches_counted<I: Input>(&self, input: I) -> (I, usize) { ... }
    fn by_ref(&self) -> Ref<'_, Self> { ... }
    fn or<Other: Pattern>(self, other: Other) -> Union<Self, Other>
       where Self: Sized { ... }
    fn not_escaped_by<Prefix: Pattern>(
        self,
        prefix: Prefix,
    ) -> NotEscaped<Prefix, Self>
       where Self: Sized { ... }
    fn not_enclosed_by<Enclosure: Pattern>(
        self,
        enc: Enclosure,
    ) -> NotEnclosed<Enclosure, Self>
       where Self: Sized { ... }
}

This trait represents an object that can be matched onto a string. This includes functions, characters, [arrays of] characters, strings, but also custom patterns like NotEscaped

See built-in patterns and parser adapters for patterns in the pattern module

Hint: on the success path, the 1st element of the return tuple is the rest of the input (with or without the matched pattern at the start)

Required Methods

fn immediate_match<I: Input>(&self, input: I) -> Result<(I, I), I>

The return values are (rest of the input, matched fragment at the beginning).

Errors

In the case of no match, the original input is returned as the Err variant.

Used by parse.

fn trailing_match<I: Input>(&self, input: I) -> Result<(I, I), I>

Like Pattern::immediate_match, but matches at the end of input. The return values are (the input before the match, the match)

Errors

In the case of no match, the original input is returned as the Err variant.

Used by the Pattern impl of NotEscaped

fn first_match<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

The return values are (the match + rest of the input, (string before the match, the match)).

Errors

Returns the provided input unchanged in the Err variant if there’s no match.

Used by parse_until.

fn first_match_ex<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

Like Pattern::first_match, but the match is excluded from the rest of the input.

Errors

Returns the provided input unchanged in the Err variant if there’s no match.

Used by parse_until_ex.

Provided Methods

fn immediate_matches<I: Input>(&self, input: I) -> (I, I)

The return values are (rest of the input, contiguous matched fragments from the beginning).

0 is also a valid number of matches.

Used by parse_while

fn immediate_matches_counted<I: Input>(&self, input: I) -> (I, (I, usize))

Like Pattern::immediate_matches, but also counts the number of matches.

Used by the Pattern impl of NotEscaped

fn trailing_matches_counted<I: Input>(&self, input: I) -> (I, usize)

Like Pattern::immediate_matches_counted, but matches at the end of input, and doesn’t return the matched fragment of the input.

Used by the Pattern impl of NotEscaped

fn by_ref(&self) -> Ref<'_, Self>

Get the pattern by reference to avoid moving it, which will happen in generic code

Do not override this method.

fn or<Other: Pattern>(self, other: Other) -> Union<Self, Other>

where Self: Sized,

Combine self and another pattern into a pattern that matches either of them in a short-circuiting manner, with self tried first.

Do not override this method.

fn not_escaped_by<Prefix: Pattern>( self, prefix: Prefix, ) -> NotEscaped<Prefix, Self>

where Self: Sized,

Create a pattern that’ll match self only if it’s not escaped (immediately preceded) by the provided pattern.

fn not_enclosed_by<Enclosure: Pattern>( self, enc: Enclosure, ) -> NotEnclosed<Enclosure, Self>

where Self: Sized,

Create a pattern that’ll match self only if it’s not enclosed (preceded & superceded) by the provided pattern.

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 Pattern for &str

fn immediate_match<I: Input>(&self, input: I) -> Result<(I, I), I>

fn immediate_matches<I: Input>(&self, input: I) -> (I, I)

fn immediate_matches_counted<I: Input>(&self, input: I) -> (I, (I, usize))

fn trailing_match<I: Input>(&self, input: I) -> Result<(I, I), I>

fn trailing_matches_counted<I: Input>(&self, input: I) -> (I, usize)

fn first_match<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

fn first_match_ex<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

impl Pattern for char

fn immediate_match<I: Input>(&self, input: I) -> Result<(I, I), I>

fn immediate_matches<I: Input>(&self, input: I) -> (I, I)

fn immediate_matches_counted<I: Input>(&self, input: I) -> (I, (I, usize))

fn trailing_match<I: Input>(&self, input: I) -> Result<(I, I), I>

fn trailing_matches_counted<I: Input>(&self, input: I) -> (I, usize)

fn first_match<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

fn first_match_ex<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

impl<L: Pattern, R: Pattern> Pattern for Either<L, R>

Available on crate feature either only.

fn immediate_match<I: Input>(&self, input: I) -> Result<(I, I), I>

fn immediate_matches<I: Input>(&self, input: I) -> (I, I)

fn immediate_matches_counted<I: Input>(&self, input: I) -> (I, (I, usize))

fn trailing_match<I: Input>(&self, input: I) -> Result<(I, I), I>

fn trailing_matches_counted<I: Input>(&self, input: I) -> (I, usize)

fn first_match<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

fn first_match_ex<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

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

This is a specialised, optimised impl for matching any char in the array. For a more general pattern combinator, use the Union pattern by calling the Pattern::or method

fn immediate_match<I: Input>(&self, input: I) -> Result<(I, I), I>

fn trailing_match<I: Input>(&self, input: I) -> Result<(I, I), I>

fn first_match<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

fn first_match_ex<I: Input>(&self, input: I) -> Result<(I, (I, I)), I>

Implementors

impl Pattern for AnyChar

impl<Enclosure: Pattern, Inner: Pattern> Pattern for NotEnclosed<Enclosure, Inner>

impl<F: Fn(char) -> bool> Pattern for F

impl<P1: Pattern, P2: Pattern> Pattern for Union<P1, P2>

impl<Prefix: Pattern, Inner: Pattern> Pattern for NotEscaped<Prefix, Inner>

impl<T: ?Sized + Pattern> Pattern for Ref<'_, T>