Pass extra argument to parser inside seq!?

[ckoehler]

In something like:

seq! {
    Frame {
        kind: be_u8.map(PacketKind::from),
        stuff: be_u16,
        packet: parse_packet(kind), // ???
    }
}.parse_next(i)

enum Packet {
  One { .. },
  Two { .. },
}

It doesn't seem to be possible with a parser like:

pub fn parse_packet(i: &mut Stream, kind: PacketKind) -> PResult<Packet>

The only way I have found is:

pub fn parse_packet(kind: PacketKind) -> impl FnMut(&mut Stream) -> PResult<Packet>

and have it return the right parser based on PacketKind. This adds a bit more overhead, since now I need a match or something to get to the right parser, whereas the first would allow me to just return the right type immediately.

Am I missing an easier way?

Thanks!

Background

The protocols we parse often have different subtypes defined in a field (like kind above), and then later parse that subtype in sometimes very different ways. We usually have an enum for the kind, and then another with struct-like variants to concisely define the individual kinds (though I am still thinking about how to simplify that even more).

[epage]

and have it return the right parser based on PacketKind. This adds a bit more overhead, since now I need a match or something to get to the right parser, whereas the first would allow me to just return the right type immediately.

Sounds like you are doing

pub fn parse_packet(kind: PacketKind) -> impl Parser<Stream, Package, ContextError> {
    match kind {
        // ...
   }
}

but you can also do

pub fn parse_packet(kind: PacketKind) -> impl Parser<Stream, Package, ContextError> {
    |stream| parse_package(stream, kind)
}

fn parse_packet_(i: &mut Stream, kind: PacketKind) -> PResult<Packet>

[ckoehler]

Ah yes. No way to inline that without changing the seq! macro, I guess?

[epage]

What do you mean by "inline" and why is that a concern?

[ckoehler]

I meant putting the closure directly into the macro, and that does work. Sorry for the noise :) Thanks!

seq! {
    Frame {
        kind: be_u8.map(PacketKind::from),
        stuff: be_u16,
        packet:  |stream| parse_package(stream, kind)
    }
}.parse_next(i)