public static IParser <S, S> Take <S>()
{
return(new Parser <S, S>(
parseF: stream =>
{
var step = stream.Unroll();
switch (step.Tag)
{
case Step.Empty:
return "End of stream.".Fail <IParsed <S, S> >().Now();
case Step.Node:
var node = (Step <S> .Node)step;
IParsed <S, S> result = new Parsed <S, S>(node.Head, node.Tail);
return result.Succeed().Now();
default:
throw new InvalidProgramException("Should never happen.");
}
}));
}
public static IParser <S, T[]> Repeat <S, T>(this IParser <S, T> parser)
{
return(new Parser <S, T[]>(
parseF: stream =>
{
var results = new List <T>();
while (true)
{
var response = parser.Parse(stream).Wait();
if (response.Throws())
{
break;
}
foreach (var parsed in response.Option().Each())
{
results.Add(parsed.Content);
stream = parsed.Stream;
}
}
IParsed <S, T[]> result = new Parsed <S, T[]>(results.ToArray(), stream);
return result.Succeed().Now();
}));
}
public static IParser <S, T> Returns <S, T>(T result)
{
return(new Parser <S, T>(
parseF: stream =>
{
IParsed <S, T> parsed = new Parsed <S, T>(result, stream);
return parsed.Succeed().Now();
}));
}
public static IParser <S, T> Peek <S, T>(Func <IStream <S>, T> lookahead)
{
return(new Parser <S, T>(
parseF: stream =>
{
var result = lookahead(stream);
IParsed <S, T> parsed = new Parsed <S, T>(result, stream);
return parsed.Succeed().Now();
}));
}
public static IParser <S, Unit> Terminated <S>()
{
return(new Parser <S, Unit>(
parseF: stream =>
{
var step = stream.Unroll();
switch (step.Tag)
{
case Step.Empty:
IParsed <S, Unit> result = new Parsed <S, Unit>(Unit.Singleton, stream);
return result.Succeed().Now();
case Step.Node:
return "Some stream content remaining.".Fail <IParsed <S, Unit> >().Now();
default:
throw new InvalidProgramException("Should never happen.");
}
}));
}
