Can we get OneOf please? about superpower HOT 10 CLOSED

Perhaps something along these lines:

public static TokenListParser<TKind, T> OneOf<TKind, T>(bool backtrack = false, params TokenListParser<TKind, T>[] parsers)
{
    if (parsers == null) throw new ArgumentNullException(nameof(parsers));

    if (parsers.Length == 0)
    {
        return i => TokenListParserResult.Empty<TKind, T>(TokenList<TKind>.Empty);
    }

    TokenListParser<TKind, T> c = parsers[0];
    for (int i = 1; i < parsers.Length; i++)
    {
        if (backtrack)
        {
            c = c.Try();
        }
        c = c.Or(parsers[i]);
    }

    return c;
}

public static TextParser<T> OneOf<T>(bool backtrack = false, params TextParser<T>[] parsers)
{
    if (parsers == null) throw new ArgumentNullException(nameof(parsers));

    if (parsers.Length == 0)
    {
        return i => Result.Empty<T>(TextSpan.None);
    }

    TextParser<T> c = parsers[0];
    for (int i = 1; i < parsers.Length; i++)
    {
        if (backtrack)
        {
            c = c.Try();
        }
        c = c.Or(parsers[i]);
    }

    return c;
}

from superpower.

I think this is an interesting feature but it's mostly sugar on top of the current API's capabilities, and makes it tempting to apply a blanket 'backtrack' when doing it surgically would provide better error reporting.

from superpower.

@nblumhardt Backtrack has never been exposed as public API before, so what you are saying is fair. Handling it with Try outside of OneOf also makes sense.

from superpower.

Apologies for the delayed response, I'll take a look 👍

from superpower.

@nblumhardt this is disappointing, especially because in the absence of examples it's difficult to understand what you mean.

from superpower.

Hi @AndrewSav - sorry about the rushed reply and close; had a few minutes to try getting the build working and issue tracker cleaned up.

Taking a look again, I think it's only the backtrack flag I'm not sold on. Backtracking can reduce the quality of error reporting if used when not necessary.

I think, though, OneOf without the flag would still be quite ergonomic:

var p = Parse.OneOf(
  First,
  Second.Try(),
  Third);

What do you think?

from superpower.

Great 👍 - If I get a chance I'll give it a shot; marking as up-for-grabs in case anyone else can take a look.

from superpower.

Will the OneOf combinator still be useful/applicable if the individual parsers are of different subtypes?

interface IStuff {}
class RedStuff : IStuff {}
class GreenStuff : IStuff {}
class BlueStuff: IStuff {}

TokenListParser<TKind, RedStuff> First;
TokenListParser<TKind, GreenStuff> Second;
TokenListParser<TKind, BlueStuff> Third;

var p = Parse.OneOf(
  First,
  Second.Try(),
  Third);

Can (or should) Parse.OneOf take care of the cast and therefore return a TokenListParser<TKind, IStuff >?
Or will it be necessary to cast each one individually (which would make the call a bit more verbose).

from superpower.

Hi @chrisspre - as it's currently envisaged, no - OneOf won't accept different parser types in its params array of alternatives. It might be possible to create various overloads: OneOf<T,U>(), OneOf<T,U,V>(), etc. to get a little closer to what you're suggesting, but there would be some fairly severe ergonomic quirks.

var p = Parse.OneOf(
  First.Cast<IStuff>(),
  Second.Cast<IStuff>().Try(),
  Third.Cast<IStuff>());

seems like the best option, as far as I can tell. HTH!

from superpower.

This feature was added in #123.

from superpower.