public static IDelayed <T2> SelectMany <T0, T1, T2>(
this IDelayed <T0> value,
Func <T0, IDelayed <T1> > selector,
Func <T0, T1, T2> projector)
{
return(value.SelectMany(value0 => selector(value0).Select(value1 => projector(value0, value1))));
}
public static IDelayed <ISeq <T2> > SelectMany <T0, T1, T2>(
this IDelayed <ISeq <T0> > delayedSeq,
Func <T0, IDelayed <ISeq <T1> > > selector,
Func <T0, T1, T2> projector)
{
return(delayedSeq.SelectMany(value0 => selector(value0).Select(value1 => projector(value0, value1))));
}
public static bool Any <T>(
this IDelayed <ISeq <T> > delayedSeq)
{
return(delayedSeq.Force().Case(
() => false,
_ => true));
}
public static Boolean Any <T>(
this IDelayed <ISeq <T> > delayedSeq)
{
return(delayedSeq.Force().Case(
empty: () => false,
headAndTail: _ => true));
}
public static T1 Foldl <T0, T1>(this IDelayed <ISeq <T0> > delayedSeq, T1 init, Func <T1, T0, T1> func)
{
return(delayedSeq.Force()
.Case(
() =>
init,
pair => pair.Item1.Foldl(func(init, pair.Item0), func)));
}
public static IEnumerable <T> AsEnumerable <T>(
this IDelayed <ISeq <T> > delayedSeq)
{
foreach (var item in delayedSeq.Select(seq => seq.AsEnumerable()).Force())
{
yield return(item);
}
}
public static Parser <TToken, T> Choice <TToken, T>(
IDelayed <ISeq <Parser <TToken, T> > > parsers)
{
return(parsers.Force().Case(
() =>
Parser.Fail <TToken, T>("Failure: Combinator.Choice"),
pair =>
pair.Item0.Or(Choice(pair.Item1))));
}
public static bool Any <T>(
this IDelayed <ISeq <T> > delayedSeq,
Func <T, bool> predicate)
{
return(delayedSeq.Force().Case(
() => false,
pair =>
predicate(pair.Item0) || pair.Item1.Any(predicate)));
}
public static Parser <TToken, T> Choice <TToken, T>(
IDelayed <ISeq <Parser <TToken, T> > > parsers)
{
return(parsers.Force().Case(
empty: () =>
Parser.Fail <TToken, T>("Failure: Combinator.Choice"),
headAndTail: pair =>
pair.Item0.Or(InternalCombinator.Choice(pair.Item1))));
}
public static void ForEach <T>(
this IDelayed <ISeq <T> > delayedSeq,
Action <T> action)
{
foreach (var item in delayedSeq.Force().AsEnumerable())
{
action(item);
}
}
public static T1 Foldr <T0, T1>(this IDelayed <ISeq <T0> > delayedSeq, T1 init, Func <T0, T1, T1> func)
{
return(delayedSeq.Force()
.Case(
empty: () =>
init,
headAndTail: pair =>
func(pair.Item0, Seq.Foldr(pair.Item1, init, func))));
}
public static Boolean Any <T>(
this IDelayed <ISeq <T> > delayedSeq,
Func <T, Boolean> predicate)
{
return(delayedSeq.Force().Case(
empty: () => false,
headAndTail: pair =>
predicate(pair.Item0) || Seq.Any(pair.Item1, predicate)));
}
public static Parser <TToken, IDelayed <ISeq <T> > > Sequence <TToken, T>(
IDelayed <ISeq <Parser <TToken, T> > > parsers)
{
return(parsers.Force().Case(
() =>
Parser.Return <TToken, IDelayed <ISeq <T> > >(Seq.Empty <T>()),
pair =>
pair.Item0.SelectMany(value0 => Sequence(pair.Item1).Select(value1 => Seq.Cons(value0, value1)))));
}
public static Parser <TToken, IDelayed <ISeq <T> > > Sequence <TToken, T>(
IDelayed <ISeq <Parser <TToken, T> > > parsers)
{
return(parsers.Force().Case(
empty: () =>
Parser.Return <TToken, IDelayed <ISeq <T> > >(Seq.Empty <T>()),
headAndTail: pair =>
pair.Item0.SelectMany(value0 => InternalCombinator.Sequence(pair.Item1).Select(value1 => Seq.Cons(value0, value1)))));
}
private TokenStreamImpl(IEnumerator <T> enumerator, Position currentPosition)
{
this.enumerator = enumerator;
Current = this.enumerator.MoveNext()
? Option.Some(Pair.Return(this.enumerator.Current, currentPosition))
: Option.None <IPair <T, Position> >();
restStream = Delayed.Return(() =>
new TokenStreamImpl <T>(enumerator, new Position(currentPosition.Line, currentPosition.Column + 1)));
}
public static IDelayed <ISeq <T> > Concat <T>(
this IDelayed <ISeq <T> > delayedSeq0,
IDelayed <ISeq <T> > delayedSeq1)
{
return(Delayed.FlatMap(delayedSeq0, seq0 =>
seq0.Case(
empty: () => delayedSeq1,
headAndTail: pair =>
Seq.Cons(pair.Item0, Delayed.Return(() => Seq.Concat(pair.Item1, delayedSeq1).Force())))));
}
public static IDelayed <ISeq <T> > Concat <T>(
this IDelayed <ISeq <T> > delayedSeq0,
IDelayed <ISeq <T> > delayedSeq1)
{
return(delayedSeq0.FlatMap(seq0 =>
seq0.Case(
() => delayedSeq1,
pair =>
Cons(pair.Item0, Delayed.Return(() => pair.Item1.Concat(delayedSeq1).Force())))));
}
public static IDelayed <ISeq <T1> > SelectMany <T0, T1>(
this IDelayed <ISeq <T0> > delayedSeq,
Func <T0, IDelayed <ISeq <T1> > > selector)
{
return(Delayed.FlatMap(delayedSeq, seq =>
seq.Case(
empty: () =>
Seq.Empty <T1>(),
headAndTail: pair =>
Seq.Concat(selector(pair.Item0), Delayed.Return(() => pair.Item1.SelectMany(selector).Force())))));
}
public static IDelayed <ISeq <T> > Where <T>(
this IDelayed <ISeq <T> > delayedSeq,
Func <T, Boolean> predicate)
{
return(Delayed.FlatMap(delayedSeq, seq =>
seq.Case(
empty: () => Seq.Empty <T>(),
headAndTail: pair => predicate(pair.Item0)
? Seq.Cons(pair.Item0, Delayed.Return(() => pair.Item1.Where(predicate).Force()))
: Delayed.Return(() => pair.Item1.Where(predicate).Force()))));
}
public static IDelayed <ISeq <T> > Where <T>(
this IDelayed <ISeq <T> > delayedSeq,
Func <T, bool> predicate)
{
return(delayedSeq.FlatMap(seq =>
seq.Case(
() => Seq.Empty <T>(),
pair => predicate(pair.Item0)
? Seq.Cons(pair.Item0, Delayed.Return(() => pair.Item1.Where(predicate).Force()))
: Delayed.Return(() => pair.Item1.Where(predicate).Force()))));
}
public static IDelayed <ISeq <T1> > Select <T0, T1>(
this IDelayed <ISeq <T0> > delayedSeq,
Func <T0, T1> selector)
{
return(delayedSeq.FlatMap(seq =>
seq.Case(
() =>
Seq.Empty <T1>(),
pair =>
Seq.Cons(selector(pair.Item0), Delayed.Return(() => pair.Item1.Select(selector)).Force()))));
}
CharStream(CharStream.Reader reader)
{
if (reader == null)
{
throw new ObjectDisposedException("reader");
}
this.reader = reader;
var currentPosition = this.reader.CurrentPosition;
var current = (this.reader.Peek() == CharStream.Reader.EOF)
? Option.None <IPair <Char, Position> >()
: Option.Some <IPair <Char, Position> >(
Pair.Return <Char, Position>((Char)this.reader.Read(), currentPosition));
this.Current = current;
this.restStream = Delayed.Return(() =>
new CharStream(this.reader));
}
private CharStream(Reader reader)
{
if (reader == null)
{
throw new ObjectDisposedException("reader");
}
this.reader = reader;
var currentPosition = this.reader.CurrentPosition;
var current = this.reader.Peek() == Reader.EOF
? Option.None <IPair <char, Position> >()
: Option.Some(
Pair.Return((char)this.reader.Read(), currentPosition));
Current = current;
restStream = Delayed.Return(() =>
new CharStream(this.reader));
}
public static Parser <TToken, T> Lazy <TToken, T>(
IDelayed <Parser <TToken, T> > delayedParser)
{
return(stream => delayedParser.Force()(stream));
}
public int CompareTo(IDelayed other)
{
return((GetRemainingDelay() - other.GetRemainingDelay()).Milliseconds);
}
public static IDelayed <T1> SelectMany <T0, T1>(
this IDelayed <T0> value,
Func <T0, IDelayed <T1> > selector)
{
return(selector(value.Force()));
}
public static IDelayed <T1> Select <T0, T1>(
this IDelayed <T0> value,
Func <T0, T1> selector)
{
return(Delayed.Return(() => selector(value.Force())));
}
public static IDelayed <T1> FlatMap <T0, T1>(
this IDelayed <T0> value,
Func <T0, IDelayed <T1> > func)
{
return(value.SelectMany(func));
}
public static IDelayed <T1> Map <T0, T1>(
this IDelayed <T0> value,
Func <T0, T1> func)
{
return(value.Select(func));
}
public int CompareTo(IDelayed other)
{
return(GetRemainingDelay().CompareTo(other.GetRemainingDelay()));
}
