Trait ParserFlat 

pub trait ParserFlat<'a, First, Last> {
    type Output;

    // Required methods
    fn then(self, next: Parser<'a, Last>) -> Self::Output;
    fn then_flat(self, next: Parser<'a, Last>) -> Self::Output;
}

Required Associated Types

type Output

Required Methods

fn then(self, next: Parser<'a, Last>) -> Self::Output

fn then_flat(self, next: Parser<'a, Last>) -> Self::Output

Implementors

impl<'a, B, C, D, E, F, G, H, I, J, K, L, Last> ParserFlat<'a, (B, C, D, E, F, G, H, I, J, K, L), Last> for Parser<'a, (B, C, D, E, F, G, H, I, J, K, L)>

where B: 'a, C: 'a, D: 'a, E: 'a, F: 'a, G: 'a, H: 'a, I: 'a, J: 'a, K: 'a, L: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, F, G, H, I, J, K, L, Last)>

impl<'a, B, C, D, E, F, G, H, I, J, K, L, M, Last> ParserFlat<'a, (B, C, D, E, F, G, H, I, J, K, L, M), Last> for Parser<'a, (B, C, D, E, F, G, H, I, J, K, L, M)>

where B: 'a, C: 'a, D: 'a, E: 'a, F: 'a, G: 'a, H: 'a, I: 'a, J: 'a, K: 'a, L: 'a, M: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, F, G, H, I, J, K, L, M, Last)>

impl<'a, B, C, D, E, F, G, H, I, J, K, L, M, N, Last> ParserFlat<'a, (B, C, D, E, F, G, H, I, J, K, L, M, N), Last> for Parser<'a, (B, C, D, E, F, G, H, I, J, K, L, M, N)>

where B: 'a, C: 'a, D: 'a, E: 'a, F: 'a, G: 'a, H: 'a, I: 'a, J: 'a, K: 'a, L: 'a, M: 'a, N: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, F, G, H, I, J, K, L, M, N, Last)>

impl<'a, B, C, D, E, F, G, H, I, J, K, Last> ParserFlat<'a, (B, C, D, E, F, G, H, I, J, K), Last> for Parser<'a, (B, C, D, E, F, G, H, I, J, K)>

where B: 'a, C: 'a, D: 'a, E: 'a, F: 'a, G: 'a, H: 'a, I: 'a, J: 'a, K: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, F, G, H, I, J, K, Last)>

impl<'a, B, C, D, E, F, G, H, I, J, Last> ParserFlat<'a, (B, C, D, E, F, G, H, I, J), Last> for Parser<'a, (B, C, D, E, F, G, H, I, J)>

where B: 'a, C: 'a, D: 'a, E: 'a, F: 'a, G: 'a, H: 'a, I: 'a, J: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, F, G, H, I, J, Last)>

impl<'a, B, C, D, E, F, G, H, I, Last> ParserFlat<'a, (B, C, D, E, F, G, H, I), Last> for Parser<'a, (B, C, D, E, F, G, H, I)>

where B: 'a, C: 'a, D: 'a, E: 'a, F: 'a, G: 'a, H: 'a, I: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, F, G, H, I, Last)>

impl<'a, B, C, D, E, F, G, H, Last> ParserFlat<'a, (B, C, D, E, F, G, H), Last> for Parser<'a, (B, C, D, E, F, G, H)>

where B: 'a, C: 'a, D: 'a, E: 'a, F: 'a, G: 'a, H: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, F, G, H, Last)>

impl<'a, B, C, D, E, F, G, Last> ParserFlat<'a, (B, C, D, E, F, G), Last> for Parser<'a, (B, C, D, E, F, G)>

where B: 'a, C: 'a, D: 'a, E: 'a, F: 'a, G: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, F, G, Last)>

impl<'a, B, C, D, E, F, Last> ParserFlat<'a, (B, C, D, E, F), Last> for Parser<'a, (B, C, D, E, F)>

where B: 'a, C: 'a, D: 'a, E: 'a, F: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, F, Last)>

impl<'a, B, C, D, E, Last> ParserFlat<'a, (B, C, D, E), Last> for Parser<'a, (B, C, D, E)>

where B: 'a, C: 'a, D: 'a, E: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, E, Last)>

impl<'a, B, C, D, Last> ParserFlat<'a, (B, C, D), Last> for Parser<'a, (B, C, D)>

where B: 'a, C: 'a, D: 'a, Last: 'a,

type Output = Parser<'a, (B, C, D, Last)>

impl<'a, B, C, Last> ParserFlat<'a, (B, C), Last> for Parser<'a, (B, C)>

where B: 'a, C: 'a, Last: 'a,

type Output = Parser<'a, (B, C, Last)>