Struct Chain 

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

A pattern that matches P1 immediately followed by P2.

A match is only produced when both patterns match consecutively at the same position: P1 at the current position and P2 right after it. The combined match spans the entirety of both sub-matches.

Note

For first_match / first_match_ex, every occurrence of P1 in the input is tried in left-to-right order; the first one where P2 immediately follows is returned. Occurrences of P1 that are not followed by P2 are skipped.

More conveniently created via Pattern::and.

Example

use {
    shrimple_parser::{
        Pattern,
        parser::{one, until_ex},
        pattern::{ascii_digit, alphabetic, Chain},
    },
    core::convert::Infallible,
};

// Matches a digit immediately followed by an alphabetic character.
assert_eq!(
    one::<_, Infallible>(ascii_digit.and(alphabetic))("3x rest"),
    Ok((" rest", "3x")),
);

// Returns an error when the pattern is not at the start.
assert!(
    one::<_, Infallible>(ascii_digit.and(alphabetic))("x3 rest")
        .is_err()
);

// Finds the first '$' that is immediately followed by '{'.
assert_eq!(
    until_ex::<_, Infallible>('$'.and('{'))("foo${bar}"),
    Ok(("bar}", "foo")),
);

Tuple Fields

0: P1

1: P2

Trait Implementations

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P1: Copy + Pattern, P2: Copy + Pattern> Copy for Chain<P1, P2>

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

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

Formats the value using the given formatter.

impl<P1: Pattern, P2: Pattern> Pattern for Chain<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 and<Other: Pattern>(self, other: Other) -> Chain<Self, Other>

where Self: Sized,

Combine self and another pattern into a pattern that matches both of them in a sequence, with self before other

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.

fn many(self) -> Many<Self>

where Self: Sized,

Creates a greedy pattern that matches self as many times as possible. See Many

fn maybe(self) -> Maybe<Self>

where Self: Sized,

Creates a pattern that matches self 0 or 1 times. See Maybe