How would you design a list parser that supports Oxford-comma format?

[ogregoire]

Let's consider a connector being either and or or, and a list that needs to be parsed, which has the Oxford-comma format. Let's consider that the elements are a custom parser.

It should be able to parse the following use cases:

"a".             -> just an element
"a and b"        -> two elements, connected with "and"
"a or b"         -> two elements, connected with "or"
"a, b, and c"    -> three elements, connected with "and"
"a, b, c, or d"  -> four elements, connected with "or"

I have a hard time designing the most appropriate parser. This is what I came up with:

    private static final Parser<Character> COMMA = one(',');
    private static final Parser<Connector> CONNECTOR = anyOf(
            word("and").thenReturn(Connector.AND),
            word("or").thenReturn(Connector.OR));

    static <T> Parser<JoinedList<T>> list(Parser<T> element) {
        Parser<JoinedList<T>> threeOrMoreTail = COMMA.then(sequence(
                element.followedBy(COMMA).atLeastOnce(),
                CONNECTOR,
                element,
                (middle, conn, last) -> new JoinedList<T>()
                        .addAll(middle)
                        .connector(conn)
                        .add(last)));
        Parser<JoinedList<T>> pairTail = sequence(
                CONNECTOR,
                element,
                (conn, last) -> new JoinedList<T>()
                        .connector(conn)
                        .add(last));
        return element.map(first -> new JoinedList<T>().add(first))
                .optionallyFollowedBy(anyOf(threeOrMoreTail, pairTail), JoinedList::merge);
    }

JoinedList is an Iterable tool that allows me to build a list fluently; it also stores the connector which is an enum {AND,OR}.

I tried to use .atLeastOnceDelimitedBy(), but that felt awkard. How would you parse it, most-idiomatically, with dot-parse?

[fluentfuture]

That's an interesting problem!

Just thinking out loud while I'm typing...

Aassuming and and or are reserved words defined in the Connector enum, and we have a term parser:

static final Set<String> RESERVED = Arrays.stream(Connector.values()).map(Object::toString).toSet();
static final Parser<Connector> CONNECTOR = Parser.anyOf(Connector.values());
Parser<String> term = Parser.word().suchThat(w -> !RESERVED.contains(w), "term");

And I assume Oxford doesn't like and/or being nested (it has to be only before the last term).

An oxford is either a single term, or two parts connected by the connector. The let part of the connected form must be either a single term, or a list of terms with a trailing comma.

That is, you can't have a list without trailing comma, and you cannot have a trailing comma without and/or.

Parser<List<String>> left = Parser.anyOf(
    term.atLeastOnceDelimitedBy(","),followedBy(","),
    term.map(List::of));
Parser<Oxford> twoOrMore = sequence(left, CONNECTOR, term, Oxford::connected);
Parser<Oxford> oxford = Parser.anyOf(twoOrMore, term.map(Oxford::singleTerm));

But this parser is a bit more permissive because it will allow "a, and b", which is illegal, yeah?

To make it reject that, the comma delimited part really isn't "at least once" but must be "at least twice". So use a suchThat() to quantify:

Parser<List<String>> left = Parser.anyOf(
    term.atLeastOnceDelimitedBy(","),followedBy(",")
        .suchThat(terms -> terms.size() >= 2, "at least twice"),
    term.map(List::of));
Parser<Oxford> twoOrMore = sequence(left, CONNECTOR, term, Oxford::connected);
Parser<Oxford> oxford = Parser.anyOf(twoOrMore, term.map(Oxford::singleTerm));

What do you think?

[fluentfuture]

Well. I guess you are right, we don't need atLeastOnceDelimitedBy(). Just use atLeastOnce():

Parser<List<String>> left = Parser.anyOf(
    term.followedBy(",").atLeastOnce()
        .suchThat(terms -> terms.size() >= 2, "at least twice"),
    term.map(List::of));
Parser<Oxford> twoOrMore = sequence(left, CONNECTOR, term, Oxford::connected);
Parser<Oxford> oxford = Parser.anyOf(twoOrMore, term.map(Oxford::singleTerm));

[fluentfuture]

For that "at least twice" thing, if you need it often, you can consider building your own combinator:

static Parser<List<T>> twoOrMore(Parser<? extends T> parser) {
  return sequence(
        parser, parser.atLeastOnce(),
        (first, remaining) ->
            Stream.concat(Stream.of(first), remaining.stream()).collect(toUnmodifiableList()));
}

Or, if avoiding the new list copy is critical:

static Parser<Deque<T>> twoOrMore(Parser<? extends T> parser) {
  return sequence(
        parser, parser.atLeastOnce(toCollection(ArrayDeque::new)),
        (first, remaining) -> {
          remaining.addFirst(first);
          return remaining;
        });
}

EDIT: on second thought, I still think using .atLeastOnce().suchThat(list -> list.size() >= 2) is both easier and more efficient.