Factor out some of the common parts of the grammar

DefaultGrammar.cs

@@ -8,7 +8,13 @@ public static class DefaultGrammar {
   public static PrecedenceDAG DefaultPrecedenceDAG
     = EmptyPrecedenceDAG
       .WithOperator("bool",     NonAssociative, "equality|terminal", S.And, "equality|terminal")
-      .WithOperator("equality", NonAssociative, "int", S.Eq, "int")
+      .WithOperator("equality", NonAssociative, "int|terminal|additive|multiplicative", S.Eq, "int|terminal|additive|multiplicative")
       .WithOperator("int",      NonAssociative, S.Int)
-      .WithOperator("terminal", NonAssociative, S.Ident);
+      .WithOperator("additive", LeftAssociative, "int|terminal|multiplicative", S.Plus, "int|terminal|multiplicative")
+//      .WithOperator("multiplicative", LeftAssociative, "int|terminal", S.Times, "int|terminal")
+      .WithOperator("terminal", NonAssociative, S.Ident)
+      // This is the root set of operators
+      .WithOperator("program",  NonAssociative,
+      // "bool" // TODO: this needs aliases
+      "equality|terminal", S.And, "equality|terminal");
 }

Lexer.cs

@@ -63,10 +63,12 @@ public static partial class Lexer {
       Rule(S.Space,   C.SpaceSeparator,     S.Space),
       Rule(S.Space,   EOF,                  S.End),
       Rule(S.Space,   '"',                  S.StringOpen, S.String),
-      Rule(S.Space,   new[]{'='},           S.Eq),
+      Rule(S.Space,   '=',                  S.Eq),
-      Rule(S.Eq,      new[]{'='},           S.Eq, S.Space),
+      Rule(S.Eq,      '=',                  S.Eq, S.Space),
-      Rule(S.Space,   new[]{'&'},           S.And),
+      Rule(S.Space,   '&',                  S.And),
-      Rule(S.And,     new[]{'&'},           S.And, S.Space),      
+      Rule(S.And,     '&',                  S.And, S.Space),
+      Rule(S.Space,   '+',                  S.Plus, S.Space),
+      Rule(S.Space,   '*',                  S.Times, S.Space),
       // TODO: https://unicode.org/reports/tr31/#D1 has a lot to say about
       // identifiers
       Rule(S.Space,   C.LowercaseLetter,    S.Ident),

LexerGenerator.cs

@@ -16,6 +16,8 @@ public static class LexerGenerator {
           Case("Decimal"),
           Case("Ident"),
           Case("And"),
+          Case("Plus"),
+          Case("Times"),
           Case("Eq"),
           Case("Space"),
           Case("String"),

MixFix.cs

@@ -13,19 +13,83 @@ using Hole = System.Collections.Immutable.ImmutableHashSet<
 using static Global;
 using static MixFix.Fixity;
 
-public class Foo {
-  public string v;
-  public static implicit operator Foo(string s) => new Foo{v=s};
-  public static Foo operator |(Foo a, string b) => a.v + b;
-}
-
 public static partial class MixFix {
   public partial class Grammar {
-    public static Grammar Sequence(params Grammar[] xs)
+    public static Grammar Sequence(params Grammar[] xs) {
-      => Grammar.Sequence(xs.ToImmutableList());
+      var filteredXs = xs.Where(x => !x.IsEmpty);
+      if (filteredXs.Count() == 1) {
+        return filteredXs.Single().ElseThrow(() => new Exception("TODO: use an either to prove that this is safe."));
+      } else {
+        return Grammar.Sequence(filteredXs);
+      }
+    }
 
     public static Grammar Or(params Grammar[] xs)
-      => Grammar.Or(xs.ToImmutableList());
+      => OrCleaned(xs.ToImmutableList());
+
+    // TODO: instead hide the default constructor for Or.
+    public static Grammar OrCleaned(IEnumerable<Grammar> xs) {
+      var filteredXs = xs.Where(x => !x.IsEmpty);
+      if (filteredXs.Count() == 1) {
+        return filteredXs.Single().ElseThrow(() => new Exception("TODO: use an either to prove that this is safe."));
+      } else {
+        return Grammar.Or(filteredXs);
+      }
+    }
+
+    public static Grammar Empty = Or();
+
+    public bool IsEmpty {
+      get => this.Match(
+        Or: l => l.Count() == 0,
+        Sequence: l => l.Count() == 0,
+        RepeatOnePlus: g => g.IsEmpty,
+        Terminal: t => false,
+        Rule: r => false
+      );
+    }
+
+    public static Grammar operator |(Grammar a, Grammar b)
+      => Or(a, b);
+
+    public static implicit operator Grammar((Grammar a, Grammar b) gs)
+      => Sequence(gs.a, gs.b);
+
+    public static implicit operator Grammar((Grammar a, Grammar b, Grammar c) gs)
+      => Sequence(gs.a, gs.b, gs.c);
+
+    public static bool operator true(Grammar g) => !g.IsEmpty;
+    public static bool operator false(Grammar g) => g.IsEmpty;
+
+    public Grammar this[string multiplicity] {
+      get {
+        if (multiplicity != "+") {
+          throw new Exception("Unexpected multiplicity");
+        } else {
+          if (this.IsEmpty) {
+            return Or();
+          } else {
+            return RepeatOnePlus(this);
+          }
+        }
+      }
+    }
+
+    private string Paren(bool paren, string s)
+      => paren ? $"({s})" : s;
+
+    string CustomToString()
+      => this.Match<string>(
+        Or: l => l.Count() == 0
+          ? "Or(Empty)"
+          : Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")),
+        Sequence: l => l.Count() == 0
+          ? "Sequence(Empty)"
+          : Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(",")),
+        RepeatOnePlus: g => $"({g.Str()})+",
+        Terminal: t => t.Str(),
+        Rule: r => r
+      );
   }
 
   public partial class Operator {
@@ -126,11 +190,13 @@ public static partial class MixFix {
     }
 
     // TODO: cache this for improved complexity
+    // TODO: find a better name
     public ImmutableHashSet<string> leftmostHole_ {
       get => leftmostHole.Else(ImmutableHashSet<string>.Empty);
     }
 
     // TODO: cache this for improved complexity
+    // TODO: find a better name
     public ImmutableHashSet<string> rightmostHole_ {
       get => rightmostHole.Else(ImmutableHashSet<string>.Empty);
     }
@@ -243,67 +309,47 @@ public static partial class MixFix {
         associativity: associativity,
         parts: parts.ToImmutableList()));
 
-  public static Grammar HoleToGrammar(PrecedenceDAG precedenceDAG, Hole precedenceGroups)
+  public static Grammar ToGrammar(this Hole precedenceGroups)
-  => Grammar.Or(
+    => Grammar.OrCleaned(
-      precedenceGroups.Select(precedenceGroup =>
+         precedenceGroups.Select(precedenceGroup =>
-        DAGNodeToGrammar(precedenceDAG, precedenceDAG[precedenceGroup])));
+           Grammar.Rule(precedenceGroup)));
 
-  public static Grammar PartToGrammar(PrecedenceDAG precedenceDAG, Part part)
+  public static Grammar ToGrammar(this Part part)
     => part.Match(
       Name: name => Grammar.Terminal(name), 
-      Hole: precedenceGroups => HoleToGrammar(precedenceDAG, precedenceGroups));
+      Hole: precedenceGroups => precedenceGroups.ToGrammar());
 
-  public static Grammar OperatorToGrammar(PrecedenceDAG precedenceDAG, Operator @operator)
+  public static Grammar ToGrammar(this Operator @operator)
     => Grammar.Sequence(
-      @operator.internalParts.Select(
+      @operator.internalParts.Select(part => part.ToGrammar()));
-        part => PartToGrammar(precedenceDAG, part)));
 
-  public static Grammar OperatorsToGrammar(PrecedenceDAG precedenceDAG, IEnumerable<Operator> operators)
+  public static Grammar ToGrammar(this IEnumerable<Operator> operators)
-    => Grammar.Or(
+    => Grammar.OrCleaned(
-      operators.Select(@operator =>
+      operators.Select(@operator => @operator.ToGrammar()));
-        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
 
+  public static Grammar ToGrammar(this DAGNode node) {
+    var lsucc = node.leftmostHole_.ToGrammar();
+    var rsucc = node.rightmostHole_.ToGrammar();
+    var closed = node.closed.ToGrammar();
+    var nonAssoc = node.infixNonAssociative.ToGrammar();
+    var prefix = node.prefix.ToGrammar();
+    var postfix = node.postfix.ToGrammar();
+    var infixl = node.infixLeftAssociative.ToGrammar();
+    var infixr = node.infixRightAssociative.ToGrammar();
 
+    // TODO: BUG: only include these parts if there are
+    // any operators with that fixity.
+    return
+        closed
+      | (nonAssoc ? (lsucc, nonAssoc, rsucc) : Grammar.Empty)
       // TODO: post-processsing of the leftassoc list.
-      Grammar.Sequence(
+      | ((prefix || infixr) ? ((prefix | (lsucc, infixr))["+"], rsucc) : Grammar.Empty)
-        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(
+      | ((postfix || infixl) ? (lsucc, (postfix | (infixl, rsucc))["+"]) : Grammar.Empty);
-        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 void DAGToGrammar(PrecedenceDAG precedenceDAG) {
+  public static ImmutableDictionary<string, Grammar> DAGToGrammar(PrecedenceDAG precedenceDAG)
-    
+    => precedenceDAG.ToImmutableDictionary(
-  }
+      node => node.Key,
-
+      node => node.Value.ToGrammar());
-  public static void RecursiveDescent(IEnumerable<Lexeme> e) {
-
-  }
 }

MixFixGenerator.cs

@@ -16,7 +16,8 @@ public static class ParserGenerator {
           Case("Grammar",              "RepeatOnePlus"),
           Case("IEnumerable<Grammar>", "Or"),
           Case("IEnumerable<Grammar>", "Sequence"),
-          Case("S",                    "Terminal")),
+          Case("S",                    "Terminal"),
+          Case("string",               "Rule")),
 
         Variant("Fixity",
           Case("Closed"),

Parser.cs

@@ -10,7 +10,7 @@ using static Global;
 
 public static partial class Parser {
   public static Ast.Expr Parse(string source) {
-    Log(DefaultGrammar.DefaultPrecedenceDAG.ToString());
+    Log(MixFix.DAGToGrammar(DefaultGrammar.DefaultPrecedenceDAG).Str());
     return Lexer.Lex(source)
       .SelectMany(lexeme =>
         lexeme.state.Match(
@@ -18,6 +18,8 @@ public static partial class Parser {
           String: () => Ast.Expr.String(lexeme.lexeme).Singleton(),
           Ident: () => Enumerable.Empty<Ast.Expr>(), // TODO
           And: () => Enumerable.Empty<Ast.Expr>(), // TODO
+          Plus: () => Enumerable.Empty<Ast.Expr>(), // TODO
+          Times: () => Enumerable.Empty<Ast.Expr>(), // TODO
           Space: () => Enumerable.Empty<Ast.Expr>(), // ignore
           Eq: () => Enumerable.Empty<Ast.Expr>(), // TODO
           End: () => Enumerable.Empty<Ast.Expr>(), // TODO
@@ -30,6 +32,10 @@ public static partial class Parser {
       .ElseThrow(() => new ParserErrorException(
         "empty file or more than one expression in file."));
   }
+
+  public static void RecursiveDescent(IEnumerable<Lexeme> e) {
+
+  }
 }
 
 // Notes:

Utils/ToString.cs

@@ -22,8 +22,11 @@ public static class ToStringImplementations {
   public static string Str<T>(this ImmutableList<MixFix.Part> l)
     => $"ImmutableList({l.Select(x => x.Str()).JoinWith(", ")})";
 
-  public static string Str<T>(this ImmutableHashSet<String> h)
+  public static string Str<T>(this ImmutableHashSet<string> h)
-    => $"ImmutableHashSet({h.Select(x => x.Str<String>()).JoinWith(", ")})";
+    => $"ImmutableHashSet({h.Select(x => x.Str<string>()).JoinWith(", ")})";
+
+  public static string Str<Grammar>(this ImmutableDictionary<string,Grammar> h)
+    => $"ImmutableDictionary(\n{h.Select(x => $"  {x.Key.Str<string>()}:{x.Value.Str<Grammar>()}").JoinWith(",\n")}\n)";
 
   public static string Str<T>(this string s) => $"\"{s}\"";