Struct NotEscaped

pub struct NotEscaped<Prefix: Pattern, Inner: Pattern>(pub Prefix, pub Inner);

Pattern that matches pattern Inner not escaped by Prefix. “escaped” here means that the pattern Inner is preceded by a Prefix that’s not preceded by itself.

For example, for a pattern NotEscaped('\', '0'), the strings “0”, “\0” & “\\\0” will have a match, but the strings “\0”, “\ \0” & “\\\\0” won’t.

Tuple Fields

0: Prefix

1: Inner

Trait Implementations

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

fn clone(&self) -> NotEscaped<Prefix, Inner>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

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

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

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)

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.

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

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.

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

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

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

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

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

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

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.

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.

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