Backtracking with commitment?

[tikitu]

I'm parsing a structure that repeats many key/value pairs in arbitrary order, where several keys tell me what the shape of their values should be, and there's a fallback option that matches any key with a catchall value parser. I can do that with OneOf, but I've been having quite some trouble tracking down mistakes in my parsers based on the error messages. I think the problem may be that if the value-parser for a particular key fails, OneOf will go on and try all the other options as well: most of them will fail fast (because their keys don't match) but the catchall can succeed, which is not what I'm looking for.

This won't compile but it gives you the idea I guess:

struct KeyValueP: ParserPrinter {
    var body: some ParserPrinter<Substring, MyEnum> {
        OneOf {
            ParsePrint {
                "list="
                ListP()
            }
            ParsePrint {
                "string="
                StringP()
            }
            ParsePrint { // fallback case
                PrefixUpTo("=")
                StringOrListP()
            }
    }
}

I guess I could handle this manually by making the fallback case explicitly say "where the prefix is not one of list= and string=", but I'm wondering if there's a solution that doesn't require the fallback knowing all the cases it should avoid. Something like Prolog's cut goal, which commits to a backtracking option, and would be used in the more specific sub-parsers to say "once my key-parser has matched, if my value-parser fails to match you should fail the entire OneOf instead of trying the next alternative".

[oskarek]

As far as I know, your best bet is to do what you already said; add that "where the prefix is not one of list= and string=" logic to the last option. This is a limitation in the library, I think, which is due to the design decision to always automatically backtrack each option within a OneOf.

You could imagine an API where the OneOf takes an optional autoBacktracks parameter, which could control this behavior. When set to false, it would no longer backtrack each option when it fails, and early out as soon as one fails when having consumed input. Then things would work as you'd expect in your example by doing:

struct KeyValueP: ParserPrinter {
  var body: some ParserPrinter<Substring, MyEnum> {
    OneOf(autoBacktrack: false) {
      ParsePrint { "list="; ListP() }
      ParsePrint { "string="; StringP()  }
      // fallback case
      ParsePrint { PrefixUpTo("="); StringOrListP() }
    }
  }
}

You could also imagine being able to fine-tune the backtracking with something like a Try parser, that backtracks the input on failure (like the Peek parser, but only backtrack when it fails).
Then you'd be able to do:

struct KeyValueP: ParserPrinter {
  var body: some ParserPrinter<Substring, MyEnum> {
    OneOf(autoBacktrack: false) {
      Try { "list="; ListP() }
      ParsePrint { "string="; StringP()  }
      // fallback case
      ParsePrint { PrefixUpTo("="); StringOrListP() }
    }
  }
}

and it would move past the "list="; ListP() option even if it fails after consuming input, but not on the next option. (in your example this is of course not be what you want, but might be useful in other scenarios)

Something like that could maybe be useful to have in the library, but it's not possible today.