How to implement a group with separator?

[SkyLeite]

Hey! Thanks for chumsky, I'm having a great time using it.

Is it possible to simplify a parser like the following? I'm not familiar with implementing variadic arguments using tuples, so I'm not sure where to even start.

    fn parse<'a>() -> impl Parser<'a, &'a str, Self> {
        group((
            number(),
            arg_sep(),
            number(),
            arg_sep(),
            number(),
            arg_sep(),
            number(),
            arg_sep(),
            bool(),
            arg_sep(),
            bool(),
            arg_sep(),
            color(),
        ))
        .map_group(|a, _, b, _, c, _, d, _, e, _, f, _, g| Self::new(a, b, c, d, e, f, g))
    }

Ideally, this new parser arg_group would be used as such:

    fn parse<'a>() -> impl Parser<'a, &'a str, Self> {
        arg_group((
            number(),
            number(),
            number(),
            number(),
            bool(),
            bool(),
            color(),
        ))
        .map_group(Self::new)
    }

[zesterer]

You can do:

let num_sep = number().then_ignore(arg_sep());

group((num_sep, num_sep, num_sep, ...))

Alternatively, if you want to accept any number of them,

number().separated_by(arg_sep()).collect::<Vec<_>>()

[SkyLeite]

Thanks! I ended up writing this helper function:

pub fn arg<'a, T>(parser: impl Parser<'a, &'a str, T>) -> impl Parser<'a, &'a str, T> {
    parser.then_ignore(arg_sep().or_not())
}

and use it as

    fn parse<'a>() -> impl Parser<'a, &'a str, Self> {
        group((
            arg(number()),
            arg(number()),
        ))
        .map_group(Self::new)
    }