devela::_dep::winnow::combinator

Trait Permutation

pub trait Permutation<I, O, E> {
    // Required method
    fn permutation(&mut self, input: &mut I) -> Result<O, ErrMode<E>> ⓘ;
}
Available on crate feature dep_winnow only.
Expand description

Helper trait for the permutation() combinator.

This trait is implemented for tuples of up to 21 elements

Required Methods§

fn permutation(&mut self, input: &mut I) -> Result<O, ErrMode<E>> ⓘ

Tries to apply all parsers in the tuple in various orders until all of them succeed

Implementations on Foreign Types§

§

impl<I, O1, O2, Error, P1, P2> Permutation<I, (O1, O2), Error> for (P1, P2)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, Error, P1, P2, P3> Permutation<I, (O1, O2, O3), Error> for (P1, P2, P3)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>,

§

fn permutation(&mut self, input: &mut I) -> Result<(O1, O2, O3), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, Error, P1, P2, P3, P4> Permutation<I, (O1, O2, O3, O4), Error> for (P1, P2, P3, P4)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, Error, P1, P2, P3, P4, P5> Permutation<I, (O1, O2, O3, O4, O5), Error> for (P1, P2, P3, P4, P5)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, Error, P1, P2, P3, P4, P5, P6> Permutation<I, (O1, O2, O3, O4, O5, O6), Error> for (P1, P2, P3, P4, P5, P6)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, Error, P1, P2, P3, P4, P5, P6, P7> Permutation<I, (O1, O2, O3, O4, O5, O6, O7), Error> for (P1, P2, P3, P4, P5, P6, P7)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, Error, P1, P2, P3, P4, P5, P6, P7, P8> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8), Error> for (P1, P2, P3, P4, P5, P6, P7, P8)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>, P13: Parser<I, O13, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>, P13: Parser<I, O13, Error>, P14: Parser<I, O14, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>, P13: Parser<I, O13, Error>, P14: Parser<I, O14, Error>, P15: Parser<I, O15, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>, P13: Parser<I, O13, Error>, P14: Parser<I, O14, Error>, P15: Parser<I, O15, Error>, P16: Parser<I, O16, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>, P13: Parser<I, O13, Error>, P14: Parser<I, O14, Error>, P15: Parser<I, O15, Error>, P16: Parser<I, O16, Error>, P17: Parser<I, O17, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>, P13: Parser<I, O13, Error>, P14: Parser<I, O14, Error>, P15: Parser<I, O15, Error>, P16: Parser<I, O16, Error>, P17: Parser<I, O17, Error>, P18: Parser<I, O18, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>, P13: Parser<I, O13, Error>, P14: Parser<I, O14, Error>, P15: Parser<I, O15, Error>, P16: Parser<I, O16, Error>, P17: Parser<I, O17, Error>, P18: Parser<I, O18, Error>, P19: Parser<I, O19, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>, P13: Parser<I, O13, Error>, P14: Parser<I, O14, Error>, P15: Parser<I, O15, Error>, P16: Parser<I, O16, Error>, P17: Parser<I, O17, Error>, P18: Parser<I, O18, Error>, P19: Parser<I, O19, Error>, P20: Parser<I, O20, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20), ErrMode<Error>> ⓘ

§

impl<I, O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21, Error, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21> Permutation<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21), Error> for (P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20, P21)
where I: Stream, Error: ParserError<I>, P1: Parser<I, O1, Error>, P2: Parser<I, O2, Error>, P3: Parser<I, O3, Error>, P4: Parser<I, O4, Error>, P5: Parser<I, O5, Error>, P6: Parser<I, O6, Error>, P7: Parser<I, O7, Error>, P8: Parser<I, O8, Error>, P9: Parser<I, O9, Error>, P10: Parser<I, O10, Error>, P11: Parser<I, O11, Error>, P12: Parser<I, O12, Error>, P13: Parser<I, O13, Error>, P14: Parser<I, O14, Error>, P15: Parser<I, O15, Error>, P16: Parser<I, O16, Error>, P17: Parser<I, O17, Error>, P18: Parser<I, O18, Error>, P19: Parser<I, O19, Error>, P20: Parser<I, O20, Error>, P21: Parser<I, O21, Error>,

§

fn permutation( &mut self, input: &mut I, ) -> Result<(O1, O2, O3, O4, O5, O6, O7, O8, O9, O10, O11, O12, O13, O14, O15, O16, O17, O18, O19, O20, O21), ErrMode<Error>> ⓘ

Implementors§