Method com.google.common.labs.parse.Parser.sequence is not public

[LeonidPozamantir]

Method
static <A, B, C> Parser sequence(
Parser.OrEmpty left, Parser right, BiFunction<? super A, ? super B, ? extends C> combiner)

in com.google.common.labs.parse.Parser is not public, probably by mistake (all other sequence overloads are public)

[fluentfuture]

The reason this method hasn't been made public (yet) is due to a concern. It will result in code that looks like return sequence(optionalP1, self) inside a recursive rule like define(). And it may undermine the following visual property:

All left recursive grammar rules are explicit.

This property makes it trivially easy to avoid left recursion. And if you run into StackOverflowError (because you didn't know left recursion is problematic), you can immediately see where the left recursion is.

return sequence(foo, self) can still cause left recursion, only now it's less explicit and depends on the programmer to tell that the foo parser is optional.

That said, I've always wondered if it should be made public though (left recursion fails quick and loud, unlike infinite loops). I just haven't run into a need in grammars I've played with.

Use cases I've run into were able to use the .prefix() method or the OperatorTable class.

Would you share your use case that needs it? The API is use case driven and it may be the one.

[LeonidPozamantir]

My use case is parsing chess move notation (like N2xd3) where only the destination field part (d3 in this example) is required.

[fluentfuture]

I see.

IIUC, chess notations can be in the form of N2xd3, Nxd3 cxd3, N2d3, Nd3, d3, accounting for taking and moving to a destination.

So assuming you have a Parser<Who> that can parse N2, N, c, and a Parser<Where> that can parse d3, maybe using Parser.anyOf() can produce reasonably readable code?

Parser<Move> chessMove = Parser.anyOf(
    sequence(who.followedBy("x"), where, Move::take),
    sequence(who, where, Move::move),
    where.map(Move::pawnMoveTo));

record Move(...) {
  static Move pawnMoveTo(Where where) {...}
  static Move move(Who who, Where where) {...}
  static Move take(Who who, Where where) {...}
}

Will that model the chess move syntax?

[fluentfuture]

Also, to parse the Who and Where, the following is what I have in mind:

Parser<Character> pieceCode = Parser.single(CharPredicate.anyOf("KQRBN"), "piece");
Parser<Integer> row = Parser.single(CharacterSet.charsIn("[1-8]"), "row").map(c -> c - '0');
Parser<Character> column = Parser.single(CharacterSet.charsIn("[a-h]"), "column");
Parser<Who> who = Parser.anyOf(
    sequence(pieceCode, row, Who::pieceAtRow),
    pieceCode.map(Who::piece),
    column.map(Who::pawnAtColumn));
Parser<where> where = sequence(column, row, Where::new);

record Who(...) {
  static Who piece(char id) {...}
  static Who pieceAtRow(int row) {...}
  static Who pawnAtColumn(char col) {...}
}

record Where(char col, int row) {...}

If your AST types are modeled differently, you can adjust it according to your design.

[LeonidPozamantir]

Sure, I meant this method is convenient to have, but not crucial. Seems it can always be expressed as combination of other sequence overloads and anyOf.

[fluentfuture]

I understand.

But the property of all-left-recursions-must-be-obvious is also tempting because it makes the library hard to misuse and easy to debug.

You are right that optionality can be expressed with combinations of sequence and anyOf(). What is to be seen is whether there are cases where using these alternatives results in awkward code.

[fluentfuture]

To clarify, unless we run into use cases where using the equivalent anyOf() would be obviously more cumbersome, I'd refrain from exposing these methods that can break the "left recursion is explicit" property.

For the chess move notation problem, it seems anyOf() may even come out at least as readable (because if you use .optional(), you'd have to add extra ifPresentOrElse() or similar conditionals to handle the two cases anyways).

Closing...