What is the cheapest-by-allocation approach for 0-or-1 elements?

[shanesveller]

Thanks for this library, I'm really enjoying it so far! I'm dabbling with Chumsky today and I have a pattern to match that loosely distills to input lines like:

A B C D E(1)..E(n)

producing a struct roughly like:

struct Foo {
  a: A,
  b: Option<B>,
  c: Option<C>,
  d: Option<D>,
  e: Option<Vec<E>>
}

where A is strictly mandatory, and all of B-E are optional, but must appear in that particular order if present (i.e. D cannot appear before C if C is present). B is a single space-delimited string that is present/absent, same for C. D should hungrily consume the rest of the line until E matches (I'm about to read #39 for this one), and then E is 0-or-more delimited strings.

So these input lines are also semantically valid:

A C D E(1)..E(n)
A D
A

I currently have, in pseudocode:

A.then(B.repeated().at_most(1)).then(C.repeated().at_most(1)).then(D.repeated().at_most(1)).then(E.repeated())

with padded sprinkled in liberally. Then to build my struct at the end of the line, I'm doing a lot of some_field_result.into_iter().next() to produce the desired Option. Did I overlook a more helpful method in the documentation to satisfy this goal? I believe my intent is comparable to nom's nom::combinator::opt.

[zesterer]

I'd suggest something like this:

a.then(b.then(c.then(d.then(e
                .repeated())
            .or_not())
        .or_not())
    .or_not())

(Chumsky's .or_not() is equivalent to Nom's opt)

which will produce the following output type, as well as guaranteeing the order you mentioned.

(A, Option<(B, Option<(C, Option<(D, Vec<E>)>)>)>)

Provided none of a/b/c/d/e allocate, this parser will not allocate either, except for the e.repeated().

EDIT: Having reread your comment, I realise that this doesn't do what you want (it doesn't allow for skipping letters). Something like this should work instead.

a.then(b.or_not().then(c.or_not()).then(d.or_not()).then(e.repeated()))

which will produce an output type of

(((((A, Option<A>), Option<B>), Option<C>), Option<D>), Vec<E>)

Again, this parser will not allocate if none of a/b/c/d/e allocate, except for the final e.repeated().

[shanesveller]

This most likely does what I needed, but I will not get to try this out very soon. Thank you very much for such a constructive and patient answer! I'll mark this as answered later if it does the trick.