public static Parser <U, TToken> SelectMany <T, U, TToken>(this Parser <T, TToken> left, Func <T, Parser <U, TToken> > func)
{
if (left is null)
{
throw new ArgumentNullException(nameof(left));
}
if (func is null)
{
throw new ArgumentNullException(nameof(func));
}
return(input =>
{
var leftResult = left(input);
if (!leftResult.IsSuccessful)
{
return ParserResult.Error <T, U, TToken>(leftResult);
}
var rightParser = func(leftResult.Result);
return rightParser(leftResult.RemainingLexemes);
});
}
public static Parser <List <T>, TToken> Many <T, TToken>(this Parser <T, TToken> parser, int least = 0, int most = int.MaxValue)
{
if (parser is null)
{
throw new ArgumentNullException(nameof(parser));
}
return(input =>
{
List <T> elements = new List <T>();
LexemeString <TToken> remainder = input;
for (int i = 0; i <= most; i++)
{
var result = parser(remainder);
if (!result.IsSuccessful)
{
if (i < least)
{
return ParserResult.Error <T, List <T>, TToken>(result);
//return ParserResult.Error<List<T>, TToken>("Too few elements. Expected at least " + least, remainder);
}
return ParserResult.Success(elements, remainder);
}
elements.Add(result.Result);
remainder = result.RemainingLexemes;
}
return ParserResult.Success(elements, remainder);
});
}
public static Parser <T, TToken> Or <T, TToken>(this Parser <T, TToken> left, Parser <T, TToken> right)
{
if (left is null)
{
throw new ArgumentNullException(nameof(left));
}
if (right is null)
{
throw new ArgumentNullException(nameof(right));
}
return(input =>
{
var leftResult = left(input);
if (leftResult.IsSuccessful)
{
return leftResult;
}
var rightResult = right(input);
if (rightResult.IsSuccessful)
{
return rightResult;
}
return ParserResult.Error(leftResult, rightResult);
});
}
public static Parser <V, TToken> SelectMany <T, U, V, TToken>(this Parser <T, TToken> left, Func <T, Parser <U, TToken> > right, Func <T, U, V> selector)
{
if (left is null)
{
throw new ArgumentNullException(nameof(left));
}
if (right is null)
{
throw new ArgumentNullException(nameof(right));
}
if (selector is null)
{
throw new ArgumentNullException(nameof(selector));
}
return(input =>
{
var leftResult = left(input);
if (!leftResult.IsSuccessful)
{
return ParserResult.Error <T, V, TToken>(leftResult);
}
var rightResult = right(leftResult.Result)(leftResult.RemainingLexemes);
if (!rightResult.IsSuccessful)
{
return ParserResult.Error <U, V, TToken>(rightResult);
}
return ParserResult.Success(selector(leftResult.Result !, rightResult.Result !), rightResult.RemainingLexemes);
});
}
public static Parser <U, TToken> Select <T, U, TToken>(this Parser <T, TToken> parser, Func <T, U> selector)
{
if (parser is null)
{
throw new ArgumentNullException(nameof(parser));
}
if (selector is null)
{
throw new ArgumentNullException(nameof(selector));
}
return(input =>
{
var result = parser(input);
if (!result.IsSuccessful)
{
return ParserResult.Error <T, U, TToken>(result);
}
return ParserResult.Success(selector(result.Result !), result.RemainingLexemes);
});
}
/// <summary> /// Returns a parser error with message <paramref name="errorMessage"/>. /// </summary> /// <typeparam name="T">The return type of the parser.</typeparam> /// <typeparam name="TToken">The type of the tokens.</typeparam> /// <param name="errorMessage">The error message to return.</param> /// <returns>The parser created.</returns> public static Parser <T, TToken> Error <T, TToken>(string errorMessage) => input => ParserResult.Error <T, TToken>(errorMessage, input);
/// <summary>
/// Parses a singular lexeme from the input and advances the input by one.
/// Returns an error with <paramref name="errorMessage"/> if the input is empty.
/// </summary>
/// <typeparam name="TToken">The type of the tokens.</typeparam>
/// <param name="errorMessage">The error message to return.</param>
/// <returns>The parser created.</returns>
public static Parser <Lexeme <TToken>, TToken> One <TToken>(string errorMessage) =>
input =>
input.Length == 0
? ParserResult.Error <Lexeme <TToken>, TToken>(errorMessage, input)
: ParserResult.Success(input[0], input.Advance(1));
