Struct UpdateState

pub struct UpdateState<P, F>(/* private fields */);

Trait Implementations

impl<P: Clone, F: Clone> Clone for UpdateState<P, F>

fn clone(&self) -> UpdateState<P, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, P, F> Parser<'a> for UpdateState<P, F>

where P: Parser<'a> + 'a, F: Fn(&P::Output, P::State) -> P::State,

type Output = <P as Parser<'a>>::Output

type State = <P as Parser<'a>>::State

fn parse( &mut self, input: &'a str, location: Location, state: Self::State, ) -> ParseResult<'a, Self::Output, Self::State>

Parse a given input, starting at a given location and state.

fn run( &mut self, input: &'a str, state: Self::State, ) -> ParseResult<'a, Self::Output, Self::State>

Run the parser on a given input, starting at the first character.

fn map<F, NewOutput: 'a>(self, map_fn: F) -> Map<Self, F>

where Self: Sized + 'a, F: Fn(Self::Output) -> NewOutput + 'a,

Map the output to a new output if parse succeeds. Otherwise, return error as usual.

fn map_with_state<F, NewOutput: 'a>(self, map_fn: F) -> MapWithState<Self, F>

where Self: Sized + 'a, F: Fn(Self::Output, Self::State) -> NewOutput + 'a,

The map function is supplied both the output and the state of the parser. Otherwise, return error as usual.

fn map_err<F>(self, map_fn: F) -> MapErr<Self, F>

where Self: Sized + 'a, F: Fn(String) -> String,

Map the error message to a new message if parse fails. Otherwise, return output as usual.

fn and_then<F, P2, B>(self, f: F) -> AndThen<Self, F>

where Self: Sized + 'a, P2: Parser<'a, Output = B>, F: Fn(Self::Output) -> P2,

Returns a new parser which is given the current output if parse succeeds. Otherwise, return error as usual.

fn pred<F>(self, predicate: F, expecting: &'a str) -> Pred<'_, Self, F>

where Self: Sized + 'a, F: Fn(&Self::Output) -> bool,

Judge if the output meets the requirement using a predicate function if the parse succeeds. Otherwise, return error as usual.

fn ignore(self) -> Ignore<Self>

where Self: Sized + 'a,

Ignore the parse output and return () (emtpy tuple)

fn update_state<F>(self, f: F) -> UpdateState<Self, F>

where Self: Sized + 'a, F: Fn(Self::Output, Self::State) -> Self::State,

Update the state given the new output and state of the parse if parse succeeds. Otherwise, return error as usual.

fn update<B, F>(self, f: F) -> Update<Self, F>

where Self: Sized + 'a, F: FnOnce(&'a str, Self::Output, Location, Self::State) -> ParseResult<'a, B, Self::State> + Clone,

Update the result of the parser if parse succeeds. Otherwise, return error as usual.

fn end(self) -> End<Self>

where Self: Sized + 'a,

Check if you have reached the end of the input you are parsing.

fn keep<A, B, P2>(self, arg_parser: P2) -> Keep<Self, P2>

where Self: Sized + 'a, Self::Output: FnOnce(A) -> B + Clone, P2: Parser<'a, Output = A>,

Keep values in a parser pipeline.

fn skip<P2>(self, ignored_parser: P2) -> Skip<Self, P2>

where Self: Sized + 'a, P2: Parser<'a>,

Skip values in a parser pipeline.

fn backtrackable(self) -> Backtrackable<Self>

where Self: Sized + 'a,

fn first_of_two<T2>(self) -> OneOfTwo<Self, T2>

where Self: Sized + 'a, T2: Parser<'a, Output = Self::Output, State = Self::State>,

fn second_of_two<T1>(self) -> OneOfTwo<T1, Self>

where Self: Sized + 'a, T1: Parser<'a, Output = Self::Output, State = Self::State>,

fn first_of_three<T2, T3>(self) -> OneOfThree<Self, T2, T3>

where Self: Sized + 'a, T2: Parser<'a, Output = Self::Output, State = Self::State>, T3: Parser<'a, Output = Self::Output, State = Self::State>,

fn second_of_three<T1, T3>(self) -> OneOfThree<T1, Self, T3>

where Self: Sized + 'a, T1: Parser<'a, Output = Self::Output, State = Self::State>, T3: Parser<'a, Output = Self::Output, State = Self::State>,

fn third_of_three<T1, T2>(self) -> OneOfThree<T1, T2, Self>

where Self: Sized + 'a, T1: Parser<'a, Output = Self::Output, State = Self::State>, T2: Parser<'a, Output = Self::Output, State = Self::State>,