[−][src]Struct combine::parser::repeat::Chainl1
Trait Implementations
impl<Input, P, Op> Parser<Input> for Chainl1<P, Op> where
Input: Stream,
P: Parser<Input>,
Op: Parser<Input>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
[src]
Input: Stream,
P: Parser<Input>,
Op: Parser<Input>,
Op::Output: FnOnce(P::Output, P::Output) -> P::Output,
type Output = P::Output
The type which is returned if the parser is successful.
type PartialState = (Option<(P::Output, Consumed<()>)>, <(Op, P) as Parser<Input>>::PartialState)
Determines the state necessary to resume parsing after more input is supplied. Read more
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_impl<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error> where
M: ParseMode,
fn add_error(&mut self, errors: &mut Tracked<<Input as StreamOnce>::Error>)
[src]
fn parse(
&mut self,
input: Input
) -> Result<(Self::Output, Input), <Input as StreamOnce>::Error>
[src]
&mut self,
input: Input
) -> Result<(Self::Output, Input), <Input as StreamOnce>::Error>
fn parse_with_state(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> Result<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> Result<Self::Output, <Input as StreamOnce>::Error>
fn parse_stream(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_lazy(
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_stream_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
ⓘImportant traits for &'_ mut Wfn by_ref(&mut self) -> &mut Self where
Self: Sized,
[src]
ⓘImportant traits for &'_ mut W
Self: Sized,
fn with<P2>(self, p: P2) -> With<Self, P2> where
Self: Sized,
P2: Parser<Input>,
[src]
Self: Sized,
P2: Parser<Input>,
fn skip<P2>(self, p: P2) -> Skip<Self, P2> where
Self: Sized,
P2: Parser<Input>,
[src]
Self: Sized,
P2: Parser<Input>,
fn and<P2>(self, p: P2) -> (Self, P2) where
Self: Sized,
P2: Parser<Input>,
[src]
Self: Sized,
P2: Parser<Input>,
fn or<P2>(self, p: P2) -> Or<Self, P2> where
Self: Sized,
P2: Parser<Input, Output = Self::Output>,
[src]
Self: Sized,
P2: Parser<Input, Output = Self::Output>,
fn then<N, F>(self, f: F) -> Then<Self, F> where
Self: Sized,
F: FnMut(Self::Output) -> N,
N: Parser<Input>,
[src]
Self: Sized,
F: FnMut(Self::Output) -> N,
N: Parser<Input>,
fn then_partial<N, F>(self, f: F) -> ThenPartial<Self, F> where
Self: Sized,
F: FnMut(&mut Self::Output) -> N,
N: Parser<Input>,
[src]
Self: Sized,
F: FnMut(&mut Self::Output) -> N,
N: Parser<Input>,
fn map<F, B>(self, f: F) -> Map<Self, F> where
Self: Sized,
F: FnMut(Self::Output) -> B,
[src]
Self: Sized,
F: FnMut(Self::Output) -> B,
fn map_input<F, B>(self, f: F) -> MapInput<Self, F> where
Self: Sized,
F: FnMut(Self::Output, &mut Input) -> B,
[src]
Self: Sized,
F: FnMut(Self::Output, &mut Input) -> B,
fn flat_map<F, B>(self, f: F) -> FlatMap<Self, F> where
Self: Sized,
F: FnMut(Self::Output) -> Result<B, <Input as StreamOnce>::Error>,
[src]
Self: Sized,
F: FnMut(Self::Output) -> Result<B, <Input as StreamOnce>::Error>,
fn message<S>(self, msg: S) -> Message<Self, S> where
Self: Sized,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
[src]
Self: Sized,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
fn expected<S>(self, msg: S) -> Expected<Self, S> where
Self: Sized,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
[src]
Self: Sized,
S: for<'s> ErrorInfo<'s, Input::Token, Input::Range>,
fn silent(self) -> Silent<Self> where
Self: Sized,
[src]
Self: Sized,
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>,
[src]
Self: Parser<Input> + Sized,
F: FnMut(Self::Output) -> Result<O, E>,
E: Into<<Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError>,
ⓘImportant traits for Iter<'a, Input, P, S, M>fn iter(
self,
input: &mut Input
) -> Iter<Input, Self, Self::PartialState, FirstMode> where
Self: Parser<Input> + Sized,
[src]
ⓘImportant traits for Iter<'a, Input, P, S, M>
self,
input: &mut Input
) -> Iter<Input, Self, Self::PartialState, FirstMode> where
Self: Parser<Input> + Sized,
ⓘImportant traits for Iter<'a, Input, P, S, M>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,
[src]
ⓘImportant traits for Iter<'a, Input, P, 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,
ⓘImportant traits for Box<W>fn boxed<'a>(
self
) -> Box<dyn Parser<Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
Self: Sized + 'a,
[src]
ⓘImportant traits for Box<W>
self
) -> Box<dyn Parser<Input, Output = Self::Output, PartialState = Self::PartialState> + 'a> where
Self: Sized + 'a,
ⓘImportant traits for Either<L, R>fn left<R>(self) -> Either<Self, R> where
Self: Sized,
R: Parser<Input, Output = Self::Output>,
[src]
ⓘImportant traits for Either<L, R>
Self: Sized,
R: Parser<Input, Output = Self::Output>,
ⓘImportant traits for Either<L, R>fn right<L>(self) -> Either<L, Self> where
Self: Sized,
L: Parser<Input, Output = Self::Output>,
[src]
ⓘImportant traits for Either<L, R>
Self: Sized,
L: Parser<Input, Output = Self::Output>,
impl<P: Clone, Op: Clone> Clone for Chainl1<P, Op>
[src]
impl<P: Copy, Op: Copy> Copy for Chainl1<P, Op>
[src]
Auto Trait Implementations
impl<P, Op> Send for Chainl1<P, Op> where
Op: Send,
P: Send,
Op: Send,
P: Send,
impl<P, Op> Sync for Chainl1<P, Op> where
Op: Sync,
P: Sync,
Op: Sync,
P: Sync,
impl<P, Op> Unpin for Chainl1<P, Op> where
Op: Unpin,
P: Unpin,
Op: Unpin,
P: Unpin,
impl<P, Op> UnwindSafe for Chainl1<P, Op> where
Op: UnwindSafe,
P: UnwindSafe,
Op: UnwindSafe,
P: UnwindSafe,
impl<P, Op> RefUnwindSafe for Chainl1<P, Op> where
Op: RefUnwindSafe,
P: RefUnwindSafe,
Op: RefUnwindSafe,
P: RefUnwindSafe,
Blanket Implementations
impl<Input, P> EasyParser<Input> for P where
Input: Stream,
P: Parser<Stream<Input>> + ?Sized,
<Input as StreamOnce>::Token: PartialEq<<Input as StreamOnce>::Token>,
<Input as StreamOnce>::Range: PartialEq<<Input as StreamOnce>::Range>,
[src]
Input: Stream,
P: Parser<Stream<Input>> + ?Sized,
<Input as StreamOnce>::Token: PartialEq<<Input as StreamOnce>::Token>,
<Input as StreamOnce>::Range: PartialEq<<Input as StreamOnce>::Range>,
fn easy_parse(
&mut self,
input: Input
) -> Result<(Self::Output, Input), ParseError<Input>> where
Input: Stream,
Stream<Input>: StreamOnce<Token = Input::Token, Range = Input::Range, Error = ParseError<Stream<Input>>, Position = Input::Position>,
Input::Position: Default,
Self: Sized + Parser<Stream<Input>>,
[src]
&mut self,
input: Input
) -> Result<(Self::Output, Input), ParseError<Input>> where
Input: Stream,
Stream<Input>: StreamOnce<Token = Input::Token, Range = Input::Range, Error = ParseError<Stream<Input>>, Position = Input::Position>,
Input::Position: Default,
Self: Sized + Parser<Stream<Input>>,
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
ⓘImportant traits for &'_ mut Wfn borrow_mut(&mut self) -> &mut T
[src]
ⓘImportant traits for &'_ mut W
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,