[−][src]Trait combine::parser::choice::ChoiceParser
ChoiceParser
represents a parser which may parse one of several different choices depending
on the input.
This is an internal trait used to overload the choice
function.
Associated Types
type Output
type PartialState: Default
Required methods
fn parse_first(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_partial(
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
Self: Sized,
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
Self: Sized,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
Implementations on Foreign Types
impl<'a, Input, P: ?Sized> ChoiceParser<Input> for &'a mut P where
Input: Stream,
P: ChoiceParser<Input>,
[src]
Input: Stream,
P: ChoiceParser<Input>,
type Output = P::Output
type PartialState = P::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
A: Parser<Input, Output = Output>,
B: Parser<Input, Output = Output>,
C: Parser<Input, Output = Output>,
D: Parser<Input, Output = Output>,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
A: Parser<Input, Output = Output>,
B: Parser<Input, Output = Output>,
C: Parser<Input, Output = Output>,
D: Parser<Input, Output = Output>,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = A<A::PartialState, B::PartialState, C::PartialState, D::PartialState, E::PartialState, F::PartialState, G::PartialState, H::PartialState, I::PartialState, J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
B: Parser<Input, Output = Output>,
C: Parser<Input, Output = Output>,
D: Parser<Input, Output = Output>,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
B: Parser<Input, Output = Output>,
C: Parser<Input, Output = Output>,
D: Parser<Input, Output = Output>,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = B<B::PartialState, C::PartialState, D::PartialState, E::PartialState, F::PartialState, G::PartialState, H::PartialState, I::PartialState, J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
C: Parser<Input, Output = Output>,
D: Parser<Input, Output = Output>,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
C: Parser<Input, Output = Output>,
D: Parser<Input, Output = Output>,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = C<C::PartialState, D::PartialState, E::PartialState, F::PartialState, G::PartialState, H::PartialState, I::PartialState, J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
D: Parser<Input, Output = Output>,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
D: Parser<Input, Output = Output>,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = D<D::PartialState, E::PartialState, F::PartialState, G::PartialState, H::PartialState, I::PartialState, J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
E: Parser<Input, Output = Output>,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = E<E::PartialState, F::PartialState, G::PartialState, H::PartialState, I::PartialState, J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
F: Parser<Input, Output = Output>,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = F<F::PartialState, G::PartialState, H::PartialState, I::PartialState, J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
G: Parser<Input, Output = Output>,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = G<G::PartialState, H::PartialState, I::PartialState, J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
H: Parser<Input, Output = Output>,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = H<H::PartialState, I::PartialState, J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (I, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
I: Parser<Input, Output = Output>,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = I<I::PartialState, J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (J, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
J: Parser<Input, Output = Output>,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = J<J::PartialState, K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (K, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
K: Parser<Input, Output = Output>,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = K<K::PartialState, L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (L, M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
L: Parser<Input, Output = Output>,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = L<L::PartialState, M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, M, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (M, N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
M: Parser<Input, Output = Output>,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = M<M::PartialState, N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, N, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (N, O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
N: Parser<Input, Output = Output>,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = N<N::PartialState, O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, O, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (O, P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
O: Parser<Input, Output = Output>,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = O<O::PartialState, P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, P, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (P, Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
P: Parser<Input, Output = Output>,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = P<P::PartialState, Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, Q, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (Q, R, S, T, U, V, X, Y, Z) where
Input: Stream,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
Q: Parser<Input, Output = Output>,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = Q<Q::PartialState, R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, R, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (R, S, T, U, V, X, Y, Z) where
Input: Stream,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
R: Parser<Input, Output = Output>,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = R<R::PartialState, S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, S, T, U, V, X, Y, Z> ChoiceParser<Input> for (S, T, U, V, X, Y, Z) where
Input: Stream,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
S: Parser<Input, Output = Output>,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = S<S::PartialState, T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, T, U, V, X, Y, Z> ChoiceParser<Input> for (T, U, V, X, Y, Z) where
Input: Stream,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
T: Parser<Input, Output = Output>,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = T<T::PartialState, U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, U, V, X, Y, Z> ChoiceParser<Input> for (U, V, X, Y, Z) where
Input: Stream,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
U: Parser<Input, Output = Output>,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = U<U::PartialState, V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, V, X, Y, Z> ChoiceParser<Input> for (V, X, Y, Z) where
Input: Stream,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
V: Parser<Input, Output = Output>,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = V<V::PartialState, X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, X, Y, Z> ChoiceParser<Input> for (X, Y, Z) where
Input: Stream,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
X: Parser<Input, Output = Output>,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = X<X::PartialState, Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, Y, Z> ChoiceParser<Input> for (Y, Z) where
Input: Stream,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
Y: Parser<Input, Output = Output>,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = Y<Y::PartialState, Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, Output, Z> ChoiceParser<Input> for (Z,) where
Input: Stream,
Z: Parser<Input, Output = Output>,
[src]
Input: Stream,
Z: Parser<Input, Output = Output>,
type Output = Output
type PartialState = Z<Z::PartialState>
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<Mode>(
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
[src]
&mut self,
mode: Mode,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
Mode: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 0] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 1] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 2] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 3] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 4] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 5] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 6] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 7] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 8] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 9] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 10] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 11] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 12] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 13] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 14] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 15] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 16] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 17] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 18] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 19] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 20] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 21] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 22] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 23] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 24] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 25] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 26] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 27] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 28] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 29] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 30] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 31] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, P> ChoiceParser<Input> for [P; 32] where
Input: Stream,
P: Parser<Input>,
[src]
Input: Stream,
P: Parser<Input>,
type Output = P::Output
type PartialState = <[P] as ChoiceParser<Input>>::PartialState
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::Error>
[src]
&mut self,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, Input::Error>
fn parse_mode_choice<M>(
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
mode: M,
input: &mut Input,
state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
impl<Input, O, P> ChoiceParser<Input> for [P] where
Input: Stream,
P: Parser<Input, Output = O>,
[src]
Input: Stream,
P: Parser<Input, Output = O>,
type Output = O
type PartialState = (usize, P::PartialState)
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_choice<M>(
&mut self,
_mode: M,
_input: &mut Input,
_state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
[src]
&mut self,
_mode: M,
_input: &mut Input,
_state: &mut Self::PartialState
) -> ParseResult<Self::Output, <Input as StreamOnce>::Error> where
M: ParseMode,
fn add_error_choice(
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)
[src]
&mut self,
error: &mut Tracked<<Input as StreamOnce>::Error>
)