Parser on immutable stream of lexemes, returns a rough representation of the AST

AstGenerator.cs

@@ -4,13 +4,16 @@ public static class AstGenerator {
   public static void Main() {
     Generate(
       "AstGenerated.cs",
-      "",
+      "using System.Collections.Generic;",
       "namespace Ast {",
       "}",
       "Ast.",
       Types(
         Variant("Expr",
           Case("int", "Int"),
-          Case("string", "String"))));
+          Case("string", "String")),
+        Variant("AstNode",
+          Case("Expr", "Terminal"),
+          Case("IEnumerable<AstNode>", "Operator"))));
   }
 }

Parser.cs

@@ -4,61 +4,74 @@ using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using Immutable;
+using Ast;
 using S = Lexer.S;
 using Lexeme = Lexer.Lexeme;
 using Grammar2 = MixFix.Grammar2;
 using static Global;
 
 public static partial class Parser {
-  public static bool Parse2(string source) {
+  public static Option<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>> Parse3(
-    Grammar2 grammar =
+    Func<IImmutableEnumerator<Lexeme>,
-      DefaultGrammar.DefaultPrecedenceDAG.ToGrammar2();
+         Grammar2,
-    Log(grammar.Str());
+         //Option<IImmutableEnumerator<Lexeme>>
-
+         Option<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>>
-    // Parse3(grammar, Lexer.Lex(source))
+         >
-    throw new NotImplementedException();
-  }
-
-  public static Option<IImmutableEnumerator<Lexeme>> Parse3(
-    Func<Grammar2,
-         IImmutableEnumerator<Lexeme>,
-         Option<IImmutableEnumerator<Lexeme>>>
       Parse3,
-    Grammar2 grammar,
+    IImmutableEnumerator<Lexeme> tokens,
-    IImmutableEnumerator<Lexeme> tokens
+    Grammar2 grammar
     ) =>
     tokens
       .FirstAndRest()
       .Match(
         None: () =>
           throw new Exception("EOF, what to do?"),
-        Some: headRest => {
+        Some: firstRest => {
-          var first = headRest.Item1;
+          // Case("IImmutableEnumerable<AstNode>", "Operator"))
-          var rest = headRest.Item2;
+          var first = firstRest.Item1;
+          var rest = firstRest.Item2;
           return grammar.Match(
             RepeatOnePlus: g =>
-              Parse3(g, rest)
+              rest.FoldMapWhileSome(restI => Parse3(restI, g))
-                .IfSome(rest1 =>
+                .If<IImmutableEnumerator<Lexeme>, IEnumerable<AstNode>>((restN, nodes) => nodes.Count() > 1)
-                  WhileSome(rest1, restI => Parse3(g, restI))),
+                .IfSome((restN, nodes) => (restN, AstNode.Operator(nodes))),
+                //.IfSome(rest1 =>
+                  // TODO: remove IfSome above (useless) && aggregate
+                //  WhileSome(rest1, restI => Parse3(restI, g))),
             // TODO: to check for ambiguous parses, we can use
             // .SingleArg(…) instead of .FirstArg(…).
             Or: l =>
-              l.First(g => Parse3(g, rest)),
+              l.First(g => Parse3(rest, g)),
-            // TODO: use a shortcut version of .Aggregate
-            // to exit early when None is returned by a step
             Sequence: l =>
-              l.BindFold(rest,
+              l.BindFoldMap(rest, (restI, g) => Parse3(restI, g))
-                        (restI, g) => Parse3(g, restI)),
+               .IfSome((restN, nodes) => (restN, AstNode.Operator(nodes))),
             Terminal: t =>
               first.state.Equals(t)
-              ? rest.Some()
+              ? (rest,
-              : None<IImmutableEnumerator<Lexeme>>()
+                 AstNode.Terminal(/* TODO: */ Expr.String(rest.ToString())))
+                .Some()
+              : None<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>>()
           );
           // TODO: at the top-level, check that the lexemes
           // are empty if the parser won't accept anything else.
         }
       );
 
+  public static Option<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>> Parse2(string source) {
+    Grammar2 grammar =
+      DefaultGrammar.DefaultPrecedenceDAG.ToGrammar2();
+    Log(grammar.Str());
+
+    var P = Func.YMemoize<
+              IImmutableEnumerator<Lexeme>,
+              Grammar2,
+              Option<ValueTuple<IImmutableEnumerator<Lexeme>, AstNode>>>(
+      Parse3
+    );
+
+    return P(Lexer.Lex(source), grammar);
+  }
+
   public static Ast.Expr Parse(string source) {
     return Lexer.Lex(source)
       .SelectMany(lexeme =>

Utils/Enumerable.cs

@@ -239,17 +239,25 @@ public static class Collection {
   public static Option<A> BindFold<T, A>(this IEnumerable<T> e, A init, Func<A, T, Option<A>> f) {
     var acc = init;
     foreach (var x in e) {
-      var @new = f(acc, x);
+      var newAcc = f(acc, x);
-      if (@new.IsNone) {
+      if (newAcc.IsNone) {
-        return Option.None<A>();
+        break;
       } else {
-        acc = @new.ElseThrow(() => new Exception("impossible"));
+        acc = newAcc.ElseThrow(new Exception("impossible"));
       }
     }
     return acc.Some();
   }
 
-  public static A WhileSome<A>(this A init, Func<A, Option<A>> f) {
+  public static Option<ValueTuple<A, IEnumerable<U>>> BindFoldMap<T, A, U>(this IEnumerable<T> e, A init, Func<A, T, Option<ValueTuple<A, U>>> f)
+    => e.BindFold(
+      (init, ImmutableStack<U>.Empty),
+      (accL, x) =>
+        f(accL.Item1, x).IfSome((newAcc, result) =>
+          (newAcc, accL.Item2.Push(result)))
+    ).IfSome((acc, l) => (acc, l.Reverse<U>()));
+
+  public static A FoldWhileSome<A>(this A init, Func<A, Option<A>> f) {
     var lastGood = init;
     while (true) {
       var @new = f(lastGood);
@@ -261,6 +269,17 @@ public static class Collection {
     }
   }
 
-  public static Option<Tuple<A, B>> WhileSome<A, B>(this Option<Tuple<A, B>> init, Func<A, B, Option<Tuple<A, B>>> f)
+  public static Option<Tuple<A, B>> FoldWhileSome<A, B>(this Option<Tuple<A, B>> init, Func<A, B, Option<Tuple<A, B>>> f)
-    => init.IfSome(ab1 => WhileSome(ab1, ab => f(ab.Item1, ab.Item2)));
+    => init.IfSome(ab1 => ab1.FoldWhileSome(ab => f(ab.Item1, ab.Item2)));
+
+  public static Option<ValueTuple<A, B>> FoldWhileSome<A, B>(this Option<ValueTuple<A, B>> init, Func<A, B, Option<ValueTuple<A, B>>> f)
+    => init.IfSome(ab1 => ab1.FoldWhileSome(ab => f(ab.Item1, ab.Item2)));
+
+  public static ValueTuple<A, IEnumerable<U>> FoldMapWhileSome<A, U>(this A init, Func<A, Option<ValueTuple<A, U>>> f)
+    => FoldWhileSome(
+      (init, ImmutableStack<U>.Empty),
+      accL =>
+        f(accL.Item1).IfSome((newAcc, result) =>
+          (newAcc, accL.Item2.Push(result)))
+    ).Pipe((acc, l) => (acc, l.Reverse<U>()));
 }

Utils/Global.cs

@@ -23,11 +23,11 @@ public static class Global {
 
   public static T To<T>(this T x) => x;
 
-  public static A WhileSome<A>(A init, Func<A, Option<A>> f)
+  public static A FoldWhileSome<A>(A init, Func<A, Option<A>> f)
-    => Collection.WhileSome(init, f);
+    => Collection.FoldWhileSome(init, f);
 
-  public static Option<Tuple<A, B>> WhileSome<A, B>(Option<Tuple<A, B>> init, Func<A, B, Option<Tuple<A, B>>> f)
+  public static Option<Tuple<A, B>> FoldWhileSome<A, B>(Option<Tuple<A, B>> init, Func<A, B, Option<Tuple<A, B>>> f)
-    => Collection.WhileSome(init, f);
+    => Collection.FoldWhileSome(init, f);
 
   public static IImmutableEnumerator<T> Empty<T>()
     => ImmutableEnumeratorExtensionMethods.Empty<T>();

Utils/Immutable/Option.cs

@@ -64,9 +64,18 @@ namespace Immutable {
     public static Option<U> IfSome<T, U>(this Option<T> o, Func<T, U> some)
       => o.Map(some);
 
+    public static Option<T> If<T>(this T value, Func<T, bool> predicate)
+      => predicate(value) ? value.Some() : Option.None<T>();
+
+    public static Option<ValueTuple<T1, T2>> If<T1, T2>(this ValueTuple<T1, T2> value, Func<T1, T2, bool> predicate)
+      => predicate(value.Item1, value.Item2) ? value.Some() : Option.None<ValueTuple<T1, T2>>();
+
     public static Option<U> IfSome<T1, T2, U>(this Option<Tuple<T1, T2>> o, Func<T1, T2, U> some)
       => o.Map(o1o2 => some(o1o2.Item1, o1o2.Item2));
 
+    public static Option<U> IfSome<T1, T2, U>(this Option<ValueTuple<T1, T2>> o, Func<T1, T2, U> some)
+      => o.Map(o1o2 => some(o1o2.Item1, o1o2.Item2));
+
     public static Option<U> Bind<T, U>(this Option<T> o, Func<T, Option<U>> f)
       => o.Match_(Some: some => f(some),
                   None: () => Option.None<U>());

Utils/Piping.cs

@@ -3,6 +3,7 @@ using System.Linq;
 
 public static class Piping {
   public static U Pipe<T, U>(this T x, Func<T, U> f) => f(x);
+  public static U Pipe<T1, T2, U>(this ValueTuple<T1, T2> x, Func<T1, T2, U> f) => f(x.Item1, x.Item2);
   
   public static void Pipe<T>(this T x, Action<T> f) => f(x);