This causes an internal error (null pointer exception) in mono when it tries to initialize the types

Makefile

@@ -8,7 +8,7 @@ run: main.exe Makefile
 	MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ mono $<
 
 main.exe: $(CS) $(GENERATED) Makefile
-	mcs -out:$@ \
+	mcs -debug+ -out:$@ \
    /reference:/usr/lib/mono/fsharp/FSharp.Core.dll \
    /reference:/usr/lib/mono/4.5/System.Collections.Immutable.dll \
    /reference:/usr/lib/mono/4.5/Facades/netstandard.dll \

Parser.cs

@@ -1,32 +1,34 @@
 using System;
 using System.Text;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using Immutable;
 using S = Lexer.S;
 using Lexeme = Lexer.Lexeme;
 using static Global;
 
-public static partial class Parser {
-  public class PrecedenceDAG: Dictionary<string, DAGNode> {};
+using PrecedenceDAG = System.Collections.Immutable.ImmutableDictionary<string, Parser.DAGNode>;
 
+public static partial class Parser {
   public static PrecedenceDAG DefaultPrecedenceDAG = new PrecedenceDAG();
 
-  public static DAGNode With(DAGNode node, Operator op) {
-    var newOp = op.fixity.Match(
-      Closed: () => node.lens.closed.Cons(op),
-      InfixLeftAssociative: () => node.lens.infixLeftAssociative.Cons(op),
-      InfixRightAssociative: () => node.lens.infixRightAssociative.Cons(op),
-      InfixNonAssociative: () => node.lens.infixNonAssociative.Cons(op),
-      Prefix: () => node.lens.prefix.Cons(op),
-      Postfix: () => node.lens.postfix.Cons(op),
-      Terminal: () => node.lens.terminal.Cons(op)
+  public static DAGNode With(DAGNode node, Operator @operator) {
+    var newNode = @operator.fixity.Match(
+      Closed: () => node.lens.closed.Cons(@operator),
+      InfixLeftAssociative: () => node.lens.infixLeftAssociative.Cons(@operator),
+      InfixRightAssociative: () => node.lens.infixRightAssociative.Cons(@operator),
+      InfixNonAssociative: () => node.lens.infixNonAssociative.Cons(@operator),
+      Prefix: () => node.lens.prefix.Cons(@operator),
+      Postfix: () => node.lens.postfix.Cons(@operator),
+      Terminal: () => node.lens.terminal.Cons(@operator)
     );
     // op.fixity, parts, holes
     throw new NotImplementedException();
   }
 
   public static PrecedenceDAG With(PrecedenceDAG precedenceDAG, Operator @operator) {
+    precedenceDAG.lens(@operator.precedenceGroup);
     /*precedenceDAG.update(
       dagNode => dagNode.Add(@operator)
     );*/

ParserGenerator.cs

@@ -24,6 +24,7 @@ public static class ParserGenerator {
           Case("Terminal")),
 
         Record("Operator",
+          Field("string", "precedenceGroup"),
           Field("Fixity", "fixity"),
           Field("ImmutableList<S>", "parts"),
           Field("ImmutableList<string>", "holes")),

Utils/Lens.cs

@@ -7,35 +7,6 @@ public interface ILens<Hole, Whole> {
   Whole Update(Func<Hole, Hole> update);
 }
 
-public sealed class ImmutableListLens<T, Whole> : ILens<ImmutableList<T>, Whole> {
-  public readonly System.Func<ImmutableList<T>, Whole> wrap;
-  public readonly ImmutableList<T> oldHole;
-
-  public ImmutableListLens(System.Func<ImmutableList<T>, Whole> wrap, ImmutableList<T> oldHole) {
-    this.wrap = wrap;
-    this.oldHole = oldHole;
-  }
-
-  // Put methods with the following signature here to focus on sub-parts of the list as needed.
-  // public ILens<ImmutableList<T>,Whole> sub-part => oldHole.sub-part.ChainLens(value => oldHole.with-sub-part(value));
-
-  public Whole Update(Func<ImmutableList<T>, ImmutableList<T>> update) => wrap(update(oldHole));
-}
-
-// Lenses for primitive types and other types that are not
-// interesting to further focus.
-public sealed class LeafLens<T, Whole> : ILens<T, Whole> {
-  public readonly System.Func<T, Whole> wrap;
-  public readonly T oldHole;
-
-  public LeafLens(System.Func<T, Whole> wrap, T oldHole) {
-    this.wrap = wrap;
-    this.oldHole = oldHole;
-  }
-
-  public Whole Update(Func<T, T> update) => wrap(update(oldHole));
-}
-
 public static class LensExtensionMethods {
   public static Whole Update<Hole, Whole>(this ILens<Hole, Whole> lens, Hole newHole)
     => lens.Update(oldHole => newHole);
@@ -59,6 +30,4 @@ public static class LensExtensionMethods {
     public LeafLens<T, Whole> ChainLens<Whole>(Func<T, Whole> wrap)
       => new LeafLens<T, Whole>(wrap: wrap, oldHole: value);
   }
-
-  public static ILens<ImmutableList<string>, Whole> ChainLens<Whole>(this ImmutableList<string> hole, System.Func<ImmutableList<string>, Whole> wrap) => new ImmutableListLens<string, Whole>(wrap: wrap, oldHole: hole);
-}
+}

Utils/Lens/ImmutableDictionaryLens.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Immutable;
+
+public sealed class ImmutableDictionaryValueLens<TKey, TValue, Whole> : ILens<TValue, Whole> {
+  public readonly Func<ImmutableDictionary<TKey, TValue>, Whole> wrap;
+  public readonly ImmutableDictionary<TKey, TValue> oldDictionary;
+  public readonly TKey oldKey;
+
+  public ImmutableDictionaryValueLens(Func<ImmutableDictionary<TKey, TValue>, Whole> wrap, ImmutableDictionary<TKey, TValue> oldDictionary, TKey oldKey) {
+    // TODO: check that key exists.
+    this.wrap = wrap;
+    this.oldDictionary = oldDictionary;
+    this.oldKey = oldKey;
+  }
+
+  // Put methods with the following signature here to focus on sub-parts of the list as needed.
+  // public ILens<ImmutableList<T>,Whole> sub-part => oldHole.sub-part.ChainLens(value => oldHole.with-sub-part(value));
+
+  public Whole Update(Func<TValue, TValue> update) {
+    var oldValue = oldDictionary[oldKey];
+    return wrap(oldDictionary.SetItem(oldKey, update(oldValue)));
+  }
+
+  public ImmutableDictionaryValueLens<TKey, TValue, Whole> UpdateKey(Func<TKey, TKey> update) {
+    var newKey = update(oldKey);
+    return new ImmutableDictionaryValueLens<TKey, TValue, Whole>(
+      wrap,
+      oldDictionary.Remove(oldKey).Add(newKey, oldDictionary[oldKey]),
+      newKey);
+  }
+}
+
+public sealed class ImmutableDictionaryLens<TKey, TValue, Whole> : ILens<ImmutableDictionary<TKey, TValue>, Whole> {
+  public readonly Func<ImmutableDictionary<TKey, TValue>, Whole> wrap;
+  public readonly ImmutableDictionary<TKey, TValue> oldHole;
+
+  public ImmutableDictionaryLens(Func<ImmutableDictionary<TKey, TValue>, Whole> wrap, ImmutableDictionary<TKey, TValue> oldHole) {
+    // TODO: check that key exists.
+    this.wrap = wrap;
+    this.oldHole = oldHole;
+  }
+
+  // Put methods with the following signature here to focus on sub-parts of the list as needed.
+  public ImmutableDictionaryValueLens<TKey, TValue, Whole> this[TKey key] {
+    get => new ImmutableDictionaryValueLens<TKey, TValue, Whole>(wrap, oldHole, key);
+  }
+  
+  public Whole Update(Func<ImmutableDictionary<TKey, TValue>, ImmutableDictionary<TKey, TValue>> update) {
+    return wrap(update(oldHole));
+  }
+}
+
+public static class ImmutableDictionaryLensExtensionMethods {
+  public static ImmutableDictionaryLens<TKey, TValue, ImmutableDictionary<TKey, TValue>> lens<TKey, TValue>(this ImmutableDictionary<TKey, TValue> d)
+    => new ImmutableDictionaryLens<TKey, TValue, ImmutableDictionary<TKey, TValue>>(x => x, d);
+
+  public static ImmutableDictionaryValueLens<TKey, TValue, Whole> UpdateKey<TKey, TValue, Whole, Whole>(this ImmutableDictionaryValueLens<TKey, TValue, Whole> lens, TKey newKey)
+    => lens.UpdateKey(oldKey => newKey);
+
+  // This would need an IFocusable<TValue> constraint which is hard to get
+  //public static ILens<ImmutableDictionary<TKey, ?>, Whole> ChainLens<TKey, Whole>(this ImmutableDictionary<TKey, ?> hole, System.Func<ImmutableDictionary<TKey, ?>, Whole> wrap)
+  //  => new ImmutableDictionaryLens<TKey, ?, Whole>(wrap: wrap, oldHole: hole);
+}

Utils/Lens/ImmutableListLens.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Immutable;
+
+public sealed class ImmutableListLens<T, Whole> : ILens<ImmutableList<T>, Whole> {
+  public readonly Func<ImmutableList<T>, Whole> wrap;
+  public readonly ImmutableList<T> oldHole;
+
+  public ImmutableListLens(Func<ImmutableList<T>, Whole> wrap, ImmutableList<T> oldHole) {
+    this.wrap = wrap;
+    this.oldHole = oldHole;
+  }
+
+  // Put methods with the following signature here to focus on sub-parts of the list as needed.
+  // public ILens<ImmutableList<T>,Whole> sub-part => oldHole.sub-part.ChainLens(value => oldHole.with-sub-part(value));
+
+  public Whole Update(Func<ImmutableList<T>, ImmutableList<T>> update) => wrap(update(oldHole));
+}
+
+public static class ImmutableListLensExtensionMethods {
+  public static ILens<ImmutableList<string>, Whole> ChainLens<Whole>(this ImmutableList<string> hole, System.Func<ImmutableList<string>, Whole> wrap)
+    => new ImmutableListLens<string, Whole>(wrap: wrap, oldHole: hole);
+}

Utils/Lens/LeafLens.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Immutable;
+
+// Lenses for primitive types and other types that are not
+// interesting to further focus.
+public sealed class LeafLens<T, Whole> : ILens<T, Whole> {
+  public readonly System.Func<T, Whole> wrap;
+  public readonly T oldHole;
+
+  public LeafLens(System.Func<T, Whole> wrap, T oldHole) {
+    this.wrap = wrap;
+    this.oldHole = oldHole;
+  }
+
+  public Whole Update(Func<T, T> update) => wrap(update(oldHole));
+}