How to handle a missing list value?

[0x8000-0000]

I would like to parse something as a list, but where some values might be missing, for example consider a CSV file:

 1,,3
 ,5,6
 7,8,

I hacked something by having an action on the separator (and if I see two separators without value, observe an empty), but I have the feeling it's not the cleanest solution. I looked through the rules but I didn't find something like opt_or_else<Foo, Bar> that would match a Foo, or trigger action for Bar if Foo wasn't available.

Thank you!

[skyrich62]

This is very similar to error recovery. Take a look at the examples for that.

My approach is to use if_then_else like this:

struct foo : digit { };      // Any single digit is a foo
struct bar : success { };  // bar always succeeds, used to activate an action or create a parse tree node.
struct COMMA : one< ',' > { };
struct ws : space { };

struct possible_foo : 
    if_then_else< 
        at< foo >,    // If we're at a foo
        foo,              // then process it
        bar              // otherwise process a bar
    > { };

struct csv : list< possible_foo, COMMA, ws > { };

This may not do exactly what you want, but it should help point you in the right direction, I think.

Given your input, the trace goes like this:

        position argv[1]:1:1
#1      3csv
#2        12possible_foo
#3          N3tao5pegtl2atIJ3fooEEE
#4            3foo
              success
              position argv[1]:1:2
            success #3 N3tao5pegtl2atIJ3fooEEE
            position argv[1]:1:1
#5          3foo
            success
            position argv[1]:1:2
          success #2 12possible_foo
#6        N3tao5pegtl8internal4starINS1_3seqIJNS2_I2wsJEEE5COMMAS5_EEEJ12possible_fooEEE
#7          N3tao5pegtl8internal3seqIJNS2_IJNS1_4starI2wsJEEE5COMMAS5_EEE12possible_fooEEE
#8            N3tao5pegtl8internal3seqIJNS1_4starI2wsJEEE5COMMAS5_EEE
#9              N3tao5pegtl8internal4starI2wsJEEE
#10               2ws
                  failure
                success #9 N3tao5pegtl8internal4starI2wsJEEE
#11             5COMMA
                success
                position argv[1]:1:3
#12             N3tao5pegtl8internal4starI2wsJEEE
#13               2ws
                  failure
                success #12 N3tao5pegtl8internal4starI2wsJEEE
              success #8 N3tao5pegtl8internal3seqIJNS1_4starI2wsJEEE5COMMAS5_EEE
#14           12possible_foo
#15             N3tao5pegtl2atIJ3fooEEE
#16               3foo
                  failure
                failure #15 N3tao5pegtl2atIJ3fooEEE
#17             3bar
                success
              success #14 12possible_foo

...
#91             5COMMA
                failure
              failure #88 N3tao5pegtl8internal3seqIJNS1_4starI2wsJEEE5COMMAS5_EEE
            failure #87 N3tao5pegtl8internal3seqIJNS2_IJNS1_4starI2wsJEEE5COMMAS5_EEE12possible_fooEEE
          success #6 N3tao5pegtl8internal4starINS1_3seqIJNS2_I2wsJEEE5COMMAS5_EEEJ12possible_fooEEE
        success #1 3csv

[0x8000-0000]

Thank you @skyrich62 - but this looks too much like my original hack - I was trying to keep my grammar expressive and clearly mapped to the intent.

[rowlesmr]

I want to try and implement a level of error recovery in my new parser. I might have to investigate this idiom.

[d-frey]

Just use sor<>:

struct Foo : ... {};
struct Bar : success {};

struct OptFoo : sor< Foo, Bar > {};

Which will trigger the action for Foo if it matches, the action for Bar otherwise.

If you want to fail the whole rule when Foo doesn't match, but you still want an action for Bar to be triggered when it fails, you can use:

struct FooWithFailActionBar : sor< Foo, seq< Bar, failure > > {};

[ColinH]

Another possibility, keeping the CSV example, is to set up the fields to also match on empty content, e.g.

struct line : seq< list< star< digit >, one< ',' > >, eolf > {};

where the action for star< digit > can easily check its action_input argument for whether it's empty.

[0x8000-0000]

Thank you, I have implemented a combination of @d-frey and @ColinH answers, because I need to be able to handle a missing value after the last comma too.