[Question] Backtrack/IsPartial how and why?

I would like to get a bit more understanding in how Backtrack and IsPartial works. I'll explain what I understand so far, and then I ask question.

Backtrack

Backtrack property of the Result object indicates that the next parser should discard the results of that parser if it failed and try something else, depending on what the next parser is. Or, Many and IgnoreMany currently use it
Backtrack is internal, so only Or, Many and IgnoreMany use is it and nothing else.
Backtrack is set by Try. It passed on by Apply, but only for TokenListParser, not for TextParser.
Since most combinators usually construct a brand new Result, Backtrack usually do not "flow".

IsPartial

Internal IsPartial property of the Result, used when HasValue is false. It means that the Position has been moved by the previous parser, despite that the parsing failed.
Practically, the most likely situation where IsPartial is true, we have a combined parser, and some of the parsers in it succeeded, but than a later parser in it failed.

Or, Many and IgnoreMany combinators All of them check condition where HasValue is false, and Backtrack is false and IsPartial is true, which means that the previous parser failed, does not have the backtrack, but has moved the current position.

Or parser will NOT process the seconds parser if the above condition is true. It will process the next parser if the above condition is false when the first parser fails.
Many parser keeps applying the previous parser until it fails. Once that has happened, it checks for the condition above. If true, it fails, otherwise it returns the results from all the parsers applied so far.
IgnoreMany returns Unit.Value when succeeds. It applies the same logic as Many combinator above.

Usage Practically, you will use the above in code in form of A.Try().Or(B), A.Try().Many(B) and A.Try().IgnoreMany(B)

Example: Many If we only have parser that does not consume any input on failure we do not need backtrack:

var parser = Character.Digit.Many();
//Parse "1" => '1'
//Parse "12" => '1','2'
//Parse "12a" => '1','2'
//Parse "." => unexpected `.`, expected digit or letter.

But once we started combining parsers, we inevitable end up with ones that fail after consuming partial input:

var parser = 
    from first in Character.Digit
    from second in Character.Letter
    select new string(new[] { first, second });
//Parse "1a" => "1a"
//Parse "12" => unexpected `2`, expected letter.

At this point 1 will be consumed and 2 will be not. So:

var parser2 = parser.Many()
//Parse "1a2b3c" => "1a","2b","3c"
//Parse "2a!y" => "2a"
//Parse "2a45" => unexpected `4`, expected letter.

In the last example, we have a partial parse of "45" and without the backtrack it fails. Let's try the same with backtrack:

var parser3 = parser.Try().Many()
//Parse "2a45" => "2a"

In this case, Many has parsed as much as it could and then stopped just before 45.

Example: Or Similarly, parser that do not consume any input on failure work work the same with or without backtrack, so I won't repeat it here. Here are a couple of parsers that do consume input on failure:

var parser1 = Span.EqualTo("keyword").Select(s => s.ToStringValue());
var parser2 =
    from first in Character.Letter
    from second in Character.Digit
    select new string(new[] { first, second });

var parser3 = parser1.Or(parser2);
//Parse "k3" => unexpected `3`, expected `e`.

Here we are not using Backtrack and k3 cannot be matched because the first parser started consuming characters, and "k" is consumed.

Question From the examples above it looks to me like Backtracking is a sensible default. I cannot imagine an example where I would like Many or Or to fail, if the previous parser consumed some input. In most cases, I would simply want it to stop and return whatever is consumed. Note, that even without Backtracking, Many will not fail if it cannot match at all, it will just return empty output.

Why does it makes sense to insist on using Try, and not making backtracking the default mode? Why does it makes sense for a failed parser to leave the position mid-parse? In which use cases the behaviour of consuming some input for a parser when failing could be desirable?

datalust / superpower

[Question] Backtrack/IsPartial how and why? #118