Struct Union

pub struct Union<P1: Pattern, P2: Pattern>(pub P1, pub P2);

A pattern that matches either of the 2 patterns in a short-circuiting manner, with self tried first. May be created by Pattern::or for convenience.

Note

If you want to match either of N chars, use an array of them as a pattern instead, as this struct has a general impl that may miss optimisations applicable to the case of [char; N] being the pattern. However, unlike the array pattern, the combination of patterns using this struct is not commutative, since the second pattern is only tried if the former has not been found in the input.

Tuple Fields

0: P1

1: P2

Trait Implementations

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

fn clone(&self) -> Union<P1, P2>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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

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 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 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 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<P1: Copy + Pattern, P2: Copy + Pattern> Copy for Union<P1, P2>