Fixed bug: an empty or is not vacuously .IsEmpty

DefaultGrammar.cs

@@ -7,11 +7,11 @@ using static MixFix.Associativity;
 public static class DefaultGrammar {
   public static PrecedenceDAG DefaultPrecedenceDAG
     = EmptyPrecedenceDAG
-      .WithOperator("bool",     NonAssociative, "equality|terminal", S.And, "equality|terminal")
+      /*.WithOperator("bool",     NonAssociative, "equality|terminal", S.And, "equality|terminal")
       .WithOperator("equality", NonAssociative, "int|terminal|additive|multiplicative", S.Eq, "int|terminal|additive|multiplicative")
       .WithOperator("int",      NonAssociative, S.Int)
       .WithOperator("additive", LeftAssociative, "int|terminal|multiplicative", S.Plus, "int|terminal|multiplicative")
-      .WithOperator("multiplicative", LeftAssociative, "int|terminal", S.Times, "int|terminal")
+      .WithOperator("multiplicative", LeftAssociative, "int|terminal", S.Times, "int|terminal")*/
       .WithOperator("terminal", NonAssociative, S.Ident)
       // This is the root set of operators
       .WithOperator("program",  NonAssociative,

MixFix.cs

@@ -68,10 +68,12 @@ public static partial class MixFix {
 
     public bool IsEmpty {
       get => this.Match(
-        Or: l => l.All(g => g.IsEmpty),
+        Or: l => l.Count() > 0 && l.All(g => g.IsEmpty),
         Sequence: l => l.All(g => g.IsEmpty),
         RepeatOnePlus: g => g.IsEmpty,
         Terminal: t => false,
+        Annotated: a => a.Item2.IsEmpty,
+        // TODO: when converting to Grammar2, make sure to recompute the .IsEmpty and .IsImpossible and .AllowsEmpty
         Rule: r => false
       );
     }
@@ -79,12 +81,13 @@ public static partial class MixFix {
     // TODO: cache this!
     public bool AllowsEmpty {
       get => this.Match(
-        Or: l => l.Any(g => g.AllowsEmpty),
+        Or: l => l.Count() > 0 && l.Any(g => g.AllowsEmpty),
         Sequence: l => l.All(g => g.IsEmpty),
         // This one should not be true, if it is
         // then the precedence graph may be ill-formed?
         RepeatOnePlus: g => g.AllowsEmpty,
         Terminal: t => false,
+        Annotated: a => a.Item2.AllowsEmpty,
         Rule: r => false
       );
     }
@@ -95,6 +98,7 @@ public static partial class MixFix {
         Sequence: l => l.Any(g => g.IsImpossible),
         RepeatOnePlus: g => g.IsImpossible,
         Terminal: t => false,
+        Annotated: a => a.Item2.IsImpossible,
         Rule: r => false
       );
     }
@@ -128,16 +132,19 @@ public static partial class MixFix {
     private string Paren(bool paren, string s)
       => paren ? $"({s})" : s;
 
-    string CustomToString() =>
+    string CustomToString()
-        this.IsEmpty ? "Empty"
+      => this.Match<string>(
-      : this.IsImpossible ? "Impossible"
-      : this.Match<string>(
         Or: l =>
-          Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")),
+          l.Count() == 0
+          ? "ImpossibleOr"
+          : Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")),
         Sequence: l =>
-          Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(", ")),
+          l.Count() == 0
+          ? "EmptySequence"
+          : Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(", ")),
         RepeatOnePlus: g => $"{g.Str()}+",
         Terminal: t => t.Str(),
+        Annotated: a => $"{a.Item1}: {a.Item2}",
         Rule: r => r
       );
   }
@@ -164,14 +171,16 @@ public static partial class MixFix {
     private string Paren(bool paren, string s)
       => paren ? $"({s})" : s;
 
-    string CustomToString() =>
+    string CustomToString()
-        this.IsEmpty ? "Empty"
+      => this.Match<string>(
-      : this.IsImpossible ? "Impossible"
-      : this.Match<string>(
         Or: l =>
-          Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")),
+          l.Count() == 0
+          ? "ImpossibleOr"
+          : Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(" | ")),
         Sequence: l =>
-          Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(", ")),
+          l.Count() == 0
+          ? "EmptySequence"
+          : Paren(l.Count() != 1, l.Select(x => x.Str()).JoinWith(", ")),
         RepeatOnePlus: g => $"{g.Str()}+",
         Terminal: t => t.Str()
       );
@@ -423,8 +432,6 @@ public static partial class MixFix {
     var infixr = node.infixRightAssociative.ToGrammar1();
 
 
-    //Log("closed.IsImpossible:"+closed.IsImpossible);
-
 
 
 
@@ -434,15 +441,15 @@ public static partial class MixFix {
     // they are empty.
 
 
-
+    Func<string, Grammar1, Grammar1> Annotated = (s, g) => Grammar1.Annotated((s, g));
 
     return
-        (closed ? closed : Grammar1.Impossible)
+        Annotated("closed", closed ? closed : Grammar1.Impossible)
-      | (nonAssoc ? (lsucc, nonAssoc, rsucc) : Grammar1.Impossible)
+      | Annotated("nonAssoc", (nonAssoc ? (lsucc, nonAssoc, rsucc) : Grammar1.Impossible))
       // TODO: post-processsing of the rightassoc list.
-      | ((prefix || infixr) ? ((prefix || (lsucc, infixr))["+"], rsucc) : Grammar1.Impossible)
+      | Annotated("prefix||infixr", ((prefix || infixr) ? ((prefix || (lsucc, infixr))["+"], rsucc) : Grammar1.Impossible))
       // TODO: post-processsing of the leftassoc list.
-      | ((postfix || infixl) ? (lsucc, (postfix || (infixl, rsucc))["+"]) : Grammar1.Impossible);
+      | Annotated("postfix||infixl", ((postfix || infixl) ? (lsucc, (postfix || (infixl, rsucc))["+"]) : Grammar1.Impossible));
   }
 
   public static EquatableDictionary<string, Grammar1> ToGrammar1(this PrecedenceDAG precedenceDAG)
@@ -462,6 +469,7 @@ public static partial class MixFix {
         }
         return recur(labeled[r], labeled);
       },
+      Annotated:     a => recur(a.Item2, labeled),
       Terminal:      t => Grammar2.Terminal(t),
       Sequence:      l => Grammar2.Sequence(l.Select(g => recur(g, labeled))),
       Or:            l => Grammar2.Or(l.Select(g => recur(g, labeled))),

MixFixGenerator.cs

@@ -20,6 +20,7 @@ public static class ParserGenerator {
           Case("IEnumerable<Grammar1>", "Or"),
           Case("IEnumerable<Grammar1>", "Sequence"),
           Case("S",                     "Terminal"),
+          Case("ValueTuple<string, Grammar1>", "Annotated"),
           Case("string",                "Rule")),
 
         Variant("Grammar2",

Utils/Global.cs

@@ -11,6 +11,11 @@ public static class Global {
   
   public static void Log (string str) => Console.WriteLine(str);
 
+  public static T Log<T>(string str, Func<T> f) {
+    Console.WriteLine(str);
+    return f();
+  }
+
   public static Unit unit { get => Unit.unit; }
 
   public static Option<T> None<T>() => Option.None<T>();