Generate grammar from precedence DAG

MixFix.cs

@@ -20,6 +20,14 @@ public class Foo {
 }
 
 public static partial class MixFix {
+  public partial class Grammar {
+    public static Grammar Sequence(params Grammar[] xs)
+      => Grammar.Sequence(xs.ToImmutableList());
+
+    public static Grammar Or(params Grammar[] xs)
+      => Grammar.Or(xs.ToImmutableList());
+  }
+
   public partial class Operator {
     private string CustomToString()
     => $"Operator(\"{precedenceGroup}\", {fixity}, {parts.Select(x => x.Match(Hole: h => h.Select(g => g.ToString()).JoinWith("|"), Name: n => $"\"{n}\"")).JoinWith(", ")})";
@@ -48,6 +56,12 @@ public static partial class MixFix {
       get => parts.Last().Bind(lastPart => lastPart.AsHole);
     }
 
+    // TODO: does this need any caching?
+    public IEnumerable<Part> internalParts {
+      get => parts.SkipWhile(part => part.IsHole)
+                  .SkipLastWhile(part => part.IsHole);
+    }
+
     private static Func<Fixity> error =
       () => throw new Exception("Internal error: unexpected fixity.");
 
@@ -110,6 +124,16 @@ public static partial class MixFix {
     public Option<ImmutableHashSet<string>> rightmostHole {
       get => allOperators.First(@operator => @operator.rightmostHole);
     }
+
+    // TODO: cache this for improved complexity
+    public ImmutableHashSet<string> leftmostHole_ {
+      get => leftmostHole.Else(ImmutableHashSet<string>.Empty);
+    }
+
+    // TODO: cache this for improved complexity
+    public ImmutableHashSet<string> rightmostHole_ {
+      get => rightmostHole.Else(ImmutableHashSet<string>.Empty);
+    }
   }
 
   public static DAGNode EmptyDAGNode = new DAGNode(
@@ -145,7 +169,7 @@ public static partial class MixFix {
     existing.IfSome(existingHole =>
       @new.IfSome(newHole => {
         if (! newHole.SetEquals(existingHole)) {
-          throw new ParserExtensionException($"Cannot extend parser with operator {@operator}, its {name} hole ({newHole.ToString()}) must either be empty or else use the same precedence groups as the existing operators in {@operator.precedenceGroup}, i.e. {existingHole}.");
+          throw new ParserExtensionException($"Cannot extend parser with operator {@operator}, its {name} hole ({newHole.ToString()}) must either be absent or else use the same precedence groups as the existing operators in {@operator.precedenceGroup}, i.e. {existingHole}.");
         }
         return unit;
       })
@@ -184,7 +208,7 @@ public static partial class MixFix {
   }
 
   public static void CheckSingleUseOfNames(PrecedenceDAG precedenceDAG, Operator @operator) {
-    // TODO: check that each name part isn't used elsewhere in a way that could cause ambiguity (use in a different namespace which is bracketed is okay, etc.). Probably something to do with paths reachable from the root.
+    // TODO: check that each name part isn't used elsewhere in a way that adding this operator would could cause ambiguity (use in a different namespace which is bracketed is okay, etc.). Probably something to do with paths reachable from the root.
   }
 
   public static void CheckNotAlias(PrecedenceDAG precedenceDAG, Operator @operator) {
@@ -193,6 +217,10 @@ public static partial class MixFix {
     }
   }
 
+  public static void CheckAcyclic(PrecedenceDAG precedenceDAG, Operator @operator) {
+    // TODO: check that the DAG stays acyclic after adding this operator
+  }
+
   public static PrecedenceDAG With(this PrecedenceDAG precedenceDAG, Operator @operator) {
     // This is where all the checks are done to ensure that the
     //   resulting grammar is well-formed and assuredly unambiguous.
@@ -204,6 +232,7 @@ public static partial class MixFix {
     CheckConsecutiveHoles(precedenceDAG, @operator);
     CheckSingleUseOfNames(precedenceDAG, @operator);
     CheckNotAlias(precedenceDAG, @operator);
+    CheckAcyclic(precedenceDAG, @operator);
     return precedenceDAG.lens[@operator.precedenceGroup].Add(@operator);
   }
 
@@ -214,23 +243,63 @@ public static partial class MixFix {
         associativity: associativity,
         parts: parts.ToImmutableList()));
 
-  public static Grammar OperatorToGrammar(Operator @operator) {
+  public static Grammar HoleToGrammar(PrecedenceDAG precedenceDAG, Hole precedenceGroups)
-    //@operator.
+  => Grammar.Or(
+      precedenceGroups.Select(precedenceGroup =>
+        DAGNodeToGrammar(precedenceDAG, precedenceDAG[precedenceGroup])));
+
+  public static Grammar PartToGrammar(PrecedenceDAG precedenceDAG, Part part)
+    => part.Match(
+      Name: name => Grammar.Terminal(name), 
+      Hole: precedenceGroups => HoleToGrammar(precedenceDAG, precedenceGroups));
+
+  public static Grammar OperatorToGrammar(PrecedenceDAG precedenceDAG, Operator @operator)
+    => Grammar.Sequence(
+      @operator.internalParts.Select(
+        part => PartToGrammar(precedenceDAG, part)));
+
+  public static Grammar OperatorsToGrammar(PrecedenceDAG precedenceDAG, IEnumerable<Operator> operators)
+    => Grammar.Or(
+      operators.Select(@operator =>
+        OperatorToGrammar(precedenceDAG, @operator)));
+
+  public static Grammar DAGNodeToGrammar(PrecedenceDAG precedenceDAG, DAGNode node) {
+    return Grammar.Or(ImmutableList<Grammar>(
+      OperatorsToGrammar(precedenceDAG, node.closed),
+      // successor_left nonassoc successor_right
+      Grammar.Sequence(
+        HoleToGrammar(precedenceDAG, node.leftmostHole_),
+        OperatorsToGrammar(precedenceDAG, node.infixNonAssociative),
+        HoleToGrammar(precedenceDAG, node.rightmostHole_)),
+      // (prefix | successor_left leftassoc)+ successor_right
+
+
+      // TODO: post-processsing of the leftassoc list.
+      Grammar.Sequence(
+        Grammar.RepeatOnePlus(
+          Grammar.Or(
+            OperatorsToGrammar(precedenceDAG, node.prefix),
+            Grammar.Sequence(
+              HoleToGrammar(precedenceDAG, node.leftmostHole_),
+              OperatorsToGrammar(precedenceDAG, node.infixRightAssociative)))),
+          HoleToGrammar(precedenceDAG, node.rightmostHole_)),
+      // successor_left (posftix | leftassoc successor_right)+
+
+
+      // TODO: post-processsing of the leftassoc list.
+      Grammar.Sequence(
+        HoleToGrammar(precedenceDAG, node.leftmostHole_),
+        Grammar.RepeatOnePlus(
+          Grammar.Or(
+            OperatorsToGrammar(precedenceDAG, node.postfix),
+            Grammar.Sequence(
+              OperatorsToGrammar(precedenceDAG, node.infixLeftAssociative),
+              HoleToGrammar(precedenceDAG, node.rightmostHole_)))))
+    ));
     throw new NotImplementedException();
   }
 
-  public static Grammar DAGNodeToGrammar(DAGNode node) {
+  public static void DAGToGrammar(PrecedenceDAG precedenceDAG) {
-//    return Grammar.Or(ImmutableList<Grammar>(
-//      node.closed
-//      closed,
-//      succl nonassoc succr,
-//      (prefix | succl rightassoc)+ succr,
-//      succl (suffix | succr rightassoc)+
-//    ));
-    throw new NotImplementedException();
-  }
-
-  public static void DAGToGrammar(DAGNode precedenceDAG) {
     
   }
 

MixFixGenerator.cs

@@ -4,7 +4,8 @@ public static class ParserGenerator {
   public static void Main() {
     Generate(
       "MixFixGenerated.cs",
-        "using System.Collections.Immutable;\n"
+        "using System.Collections.Generic;\n"
+      + "using System.Collections.Immutable;\n"
       + "using S = Lexer.S;\n"
       + "using PrecedenceGroupName = System.String;",
       "public static partial class MixFix {",
@@ -12,8 +13,10 @@ public static class ParserGenerator {
       "MixFix.",
       Types(
         Variant("Grammar",
-          Case("ImmutableList<Grammar>", "Or"),
+          Case("Grammar",              "RepeatOnePlus"),
-          Case("ImmutableList<Grammar>", "Sequence")),
+          Case("IEnumerable<Grammar>", "Or"),
+          Case("IEnumerable<Grammar>", "Sequence"),
+          Case("S",                    "Terminal")),
 
         Variant("Fixity",
           Case("Closed"),

Utils/Enumerable.cs

@@ -210,4 +210,29 @@ public static class Collection {
 
   public static bool SetEquals<T>(this ImmutableHashSet<T> a, ImmutableHashSet<T> b)
     => a.All(x => b.Contains(x)) && b.All(x => a.Contains(x));
+
+  public static (Option<T> firstElement, ImmutableQueue<T> rest) Dequeue<T>(this ImmutableQueue<T> q) {
+    if (q.IsEmpty) {
+      return (Option.None<T>(), q);
+    } else {
+      T firstElement;
+      var rest = q.Dequeue(out firstElement);
+      return (firstElement.Some(), rest);
+    }
+  }
+
+  public static IEnumerable<T> SkipLastWhile<T>(this IEnumerable<T> e, Func<T, bool> predicate) {
+    var pending = ImmutableQueue<T>.Empty;
+    foreach (var x in e) {
+      if (predicate(x)) {
+        pending = pending.Enqueue(x);
+      } else {
+        while (!pending.IsEmpty) {
+          yield return pending.Peek();
+          pending = pending.Dequeue();
+        }
+        yield return x;
+      }
+    }
+  }
 }

Utils/Immutable/Option.cs

@@ -67,6 +67,9 @@ namespace Immutable {
     public static T Else<T>(this Option<T> o, Func<T> none)
       => o.Match_(some => some, none);
 
+    public static T Else<T>(this Option<T> o, T none)
+      => o.Match_(some => some, () => none);
+
     public static Option<T> Else<T>(this Option<T> o, Func<Option<T>> none)
       => o.Match_(value => value.Some(), none);