Struct combine::parser::regex::Captures

pub struct Captures<F, R, Input>(_, _);

This is supported on crate feature regex only.

Trait Implementations

impl<F: Clone, R: Clone, Input: Clone> Clone for Captures<F, R, Input>

pub fn clone(&self) -> Captures<F, R, Input>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, Input, F, R> Parser<Input> for Captures<F, R, Input> where
    F: FromIterator<Input::Range>,
    R: Regex<Input::Range>,
    Input: RangeStream,
    Input::Range: Range, 

type Output = F

The type which is returned if the parser is successful.

type PartialState = ()

Determines the state necessary to resume parsing after more input is supplied.

pub fn parse_lazy(
    &mut self,
    input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

Parses using the stream input by calling Stream::uncons one or more times.

pub fn add_error(&mut self, error: &mut Tracked<<Input as StreamOnce>::Error>)

Adds the first error that would normally be returned by this parser if it failed with an PeekErr result.

pub fn parse(
    &mut self,
    input: Input
) -> Result<(Self::Output, Input), <Input as StreamOnce>::Error>

Entry point of the parser. Takes some input and tries to parse it.

pub fn parse_with_state(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> Result<Self::Output, <Input as StreamOnce>::Error>

Entry point of the parser when using partial parsing. Takes some input and tries to parse it.

pub fn parse_stream(
    &mut self,
    input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

Parses using the stream input by calling Stream::uncons one or more times.

pub fn parse_stream_partial(
    &mut self,
    input: &mut Input,
    state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>

Like parse_stream but supports partial parsing.

pub fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 

Borrows a parser instead of consuming it.

pub fn with<P2>(self, p: P2) -> With<Self, P2> where
    Self: Sized,
    P2: Parser<Input>, 

Discards the value of the self parser and returns the value of p. Fails if any of the parsers fails.

pub fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
    Self: Sized,
    P2: Parser<Input>, 

Discards the value of the p parser and returns the value of self. Fails if any of the parsers fails.

pub fn and<P2>(self, p: P2) -> (Self, P2) where
    Self: Sized,
    P2: Parser<Input>, 

Parses with self followed by p. Succeeds if both parsers succeed, otherwise fails. Returns a tuple with both values on success.

pub fn or<P2>(self, p: P2) -> Or<Self, P2> where
    Self: Sized,
    P2: Parser<Input, Output = Self::Output>, 

Returns a parser which attempts to parse using self. If self fails without committing it tries to consume the same input using p.

pub fn then<N, F>(self, f: F) -> Then<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> N,
    N: Parser<Input>, 

Parses using self and then passes the value to f which returns a parser used to parse the rest of the input.

pub fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
    Self: Sized,
    F: FnMut(&mut Self::Output) -> N,
    N: Parser<Input>, 

Variant of then which parses using self and then passes the value to f as a &mut reference.

pub fn then_ref<N, F>(self, f: F) -> ThenRef<Self, F> where
    Self: Sized,
    F: FnMut(&Self::Output) -> N,
    N: Parser<Input>, 

Parses using self and then passes a reference to the value to f which returns a parser used to parse the rest of the input. The value is then combined with the output of f.

pub fn map<F, B>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> B, 

Uses f to map over the parsed value.

pub fn map_input<F, B>(self, f: F) -> MapInput<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output, &mut Input) -> B, 

pub fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
    Self: Sized,
    F: FnMut(Self::Output) -> Result<B, <Input as StreamOnce>::Error>, 

Uses f to map over the output of self. If f returns an error the parser fails.

pub fn message<S>(self, msg: S) -> Message<Self, S> where
    Self: Sized,
    S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>, 

Parses with self and if it fails, adds the message msg to the error.

pub fn expected<S>(self, msg: S) -> Expected<Self, S> where
    Self: Sized,
    S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>, 

Parses with self and if it fails without consuming any input any expected errors are replaced by msg. msg is then used in error messages as "Expected msg".

pub fn silent(self) -> Silent<Self> where
    Self: Sized, 

Parses with self, if it fails without consuming any input any expected errors that would otherwise be emitted by self are suppressed.

pub fn and_then<F, O, E>(self, f: F) -> AndThen<Self, F> where
    Self: Parser<Input> + Sized,
    F: FnMut(Self::Output) -> Result<O, E>,
    E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>, 

Parses with self and applies f on the result if self parses successfully. f may optionally fail with an error which is automatically converted to a ParseError.

pub fn iter(
    self,
    input: &mut Input
) -> Iter<'_, Input, Self, Self::PartialState, FirstMode> where
    Self: Parser<Input> + Sized, 

Creates an iterator from a parser and a state. Can be used as an alternative to many when collecting directly into a Extend type is not desirable.

pub fn partial_iter<'a, 's, M>(
    self,
    mode: M,
    input: &'a mut Input,
    partial_state: &'s mut Self::PartialState
) -> Iter<'a, Input, Self, &'s mut Self::PartialState, M> where
    Self: Parser<Input> + Sized,
    M: ParseMode, 

Creates an iterator from a parser and a state. Can be used as an alternative to many when collecting directly into a Extend type is not desirable.

pub fn boxed<'a>(
    self
) -> Box<dyn Parser<Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
    Self: Sized + 'a, 

This is supported on crate feature std only.

Turns the parser into a trait object by putting it in a Box. Can be used to easily return parsers from functions without naming the type.

pub fn left<R>(self) -> Either<Self, R> where
    Self: Sized,
    R: Parser<Input, Output = Self::Output>, 

Wraps the parser into the Either enum which allows combinators such as then to return multiple different parser types (merging them to one)

pub fn right<L>(self) -> Either<L, Self> where
    Self: Sized,
    L: Parser<Input, Output = Self::Output>, 

Wraps the parser into the Either enum which allows combinators such as then to return multiple different parser types (merging them to one)

pub fn spanned(self) -> Spanned<Self> where
    Self: Sized, 

Marks errors produced inside the self parser with the span from the start of the parse to the end of it.