ImmutableDictionary

Lexer.cs

@@ -72,7 +72,7 @@ public static partial class Lexer {
       Rule(S.String,  '"',                  S.StringClose, S.Space),
     };
 
-    public static Dictionary<S, List<Rule>> Dict =
+    public static DefaultDictionary<S, List<Rule>> Dict =
       Default
         .GroupBy(r => r.oldState, r => r)
         .ToDefaultDictionary(
@@ -81,7 +81,7 @@ public static partial class Lexer {
           rs => rs.ToList()) ;
 
     // This adds transitions through an implicit empty whitespace.
-    public static Dictionary<S, List<Rule>> WithEpsilonTransitions =
+    public static DefaultDictionary<S, List<Rule>> WithEpsilonTransitions =
       Dict.ToDefaultDictionary(
         new List<Rule>(),
         kv => kv.Key,

Makefile

@@ -7,7 +7,7 @@ run: main.exe
 	mono main.exe
 
 main.exe: $(sort $(CS) $(GENERATED))
-	mcs -out:$@ $^
+	mcs -out:$@ /reference:/usr/lib/mono/fsharp/FSharp.Core.dll $^
 
 %Generated.cs: .%Generator.exe
 	mono $<

Parser.cs

@@ -12,8 +12,24 @@ public static partial class Parser {
 
   public static PrecedenceDAG DefaultPrecedenceDAG = new PrecedenceDAG();
 
-  public static PrecedenceDAG  With(PrecedenceDAG precedenceDAG, Operator @operator) {
+  public static DAGNode With(DAGNode node, Operator op) {
+/*    var newOp = op.fixity.Match(
+       Closed: () => node.WithClosed(op),
+       InfixLeftAssociative: () => node.WithInfixLeftAssociative(op),
+       InfixRightAssociative: () => node.WithInfixRightAssociative(op),
+       InfixNonAssociative: () => node.WithInfixNonAssociative(op),
+       Prefix: () => node.WithPrefix(op),
+       Postfix: () => node.WithPostFix(op),
+       Terminal: () => node.WithTerminal(op)
+    );*/
+    // op.fixity, parts, holes
+    throw new NotImplementedException();
+  }
 
+  public static PrecedenceDAG  With(PrecedenceDAG precedenceDAG, Operator @operator) {
+    /*precedenceDAG.update(
+      dagNode => dagNode.Add(@operator)
+    );*/
     throw new NotImplementedException();
   }
 

ParserGenerator.cs

@@ -24,21 +24,18 @@ public static class ParserGenerator {
           Case("Terminal")),
 
         Record("Operator",
-          Field("List<S>", "Parts"),
-          Field("List<string>", "Holes")),
-
-        Record("Closed",
-          Field("S", "openSymbol"),
-          Field("S", "closedSymbol")),
+          Field("Fixity", "fixity"),
+          Field("List<S>", "parts"),
+          Field("List<string>", "holes")),
 
         Record("DAGNode",
-          Field("List<S>", "infixLeftAssociative"),
-          Field("List<S>", "infixRightAssociative"),
-          Field("List<S>", "infixNonAssociative"),
-          Field("List<S>", "prefix"),
-          Field("List<S>", "postfix"),
-          Field("List<Closed>", "closed"),
-          Field("List<S>", "terminal"),
-          Field("List<string>", "successors"))));
+          Field("List<Operator>", "infixLeftAssociative"),
+          Field("List<Operator>", "infixRightAssociative"),
+          Field("List<Operator>", "infixNonAssociative"),
+          Field("List<Operator>", "prefix"),
+          Field("List<Operator>", "postfix"),
+          Field("List<Operator>", "closed"),
+          Field("List<Operator>", "terminal"),
+          Field("List<string>", "successorNodes"))));
   }
 }

T4/Generator.cs

@@ -16,7 +16,7 @@ public static class Generator {
     o.WriteLine($"  /* To match against an instance of {name}, write:");
     o.WriteLine($"     x.Match(");
     o.WriteLine(String.Join(",\n", variant.Select(@case => 
-                $"       {@case.Key}: {@case.Value == null ? "()" : "value"} => throw new NotImplementedYetException(),")));
+                $"       {@case.Key}: {@case.Value == null ? "()" : "value"} => throw new NotImplementedYetException()")));
     o.WriteLine($"     )");
     o.WriteLine($"  */");
 
@@ -149,6 +149,16 @@ public static class Generator {
     o.WriteLine(String.Join(",\n", record.Select(@field =>
                 $"          this.{@field.Key}")));
     o.WriteLine($"        );");
+    foreach (var @field in record) {
+      var F = @field.Key;
+      var noAtF = F.StartsWith("@") ? F.Substring(1) : F;
+      var caseF = Char.ToUpper(noAtF[0]) + noAtF.Substring(1);
+      var Ty = @field.Value;
+      o.Write($"    public {name} With{caseF}({Ty} {F}) => new {name}(");
+      o.Write(String.Join(", ", record.Select(@f => $"{f.Key}: {f.Key}")));
+      o.WriteLine(");");
+    }
+
     o.WriteLine($"  }}");
     o.WriteLine($"{footer}");
   }

Utils/Enumerable.cs

@@ -152,7 +152,7 @@ public static class Collection {
     }
   }
 
-  public static Option<V> GetValue<K, V>(this Dictionary<K, V> d, K key) {
+  public static Option<V> GetValue<K, V>(this ImmutableDictionary<K, V> d, K key) {
     V result = default(V);
     if (d.TryGetValue(key, out result)) {
       return result.Some();
@@ -161,7 +161,7 @@ public static class Collection {
     }
   }
 
-  public static V GetOrDefault<K, V>(this Dictionary<K, V> d, K key, V defaultValue) {
+  public static V GetOrDefault<K, V>(this ImmutableDictionary<K, V> d, K key, V defaultValue) {
     V result = default(V);
     if (d.TryGetValue(key, out result)) {
       return result;
@@ -169,23 +169,4 @@ public static class Collection {
       return defaultValue;
     }
   }
-
-  public class DefaultDictionary<TKey, TValue> : Dictionary<TKey, TValue> {
-    public readonly TValue defaultValue;
-    //public readonly Dictionary<TKey, TValue> dictionary;
-    
-    public DefaultDictionary(TValue defaultValue, Dictionary<TKey, TValue> dictionary) : base(dictionary) {
-      this.defaultValue = defaultValue;
-      //this.dictionary = dictionary;
-    }
-    
-    public new TValue this[TKey key] {
-      get {
-        return this.GetOrDefault(key, defaultValue);
-      }
-    }
-  }
-
-  public static DefaultDictionary<UKey, UValue> ToDefaultDictionary<T, UKey, UValue>(this IEnumerable<T> e, UValue defaultValue, Func<T, UKey> key, Func<T, UValue> value)
-    => new DefaultDictionary<UKey, UValue>(defaultValue, e.ToDictionary(key, value));
 }

Utils/Func.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Mutable = System.Collections.Generic;
 
 public static class Func {
   // supply 1 argument to function of 2 arguments
@@ -29,7 +30,7 @@ public static class Func {
   }
 
   public static Func<A, B> Memoize<A, B>(this Func<A, B> f) where A : IEquatable<A> {
-    var d = new Dictionary<A, B>();
+    var d = new Mutable.Dictionary<A, B>();
     return a => {
       if (d.TryGetValue(a, out var b)) {
         return b;

Utils/Immutable/DefaultDictionary.cs

@@ -0,0 +1,30 @@
+//namespace Immutable {
+  using System;
+  using System.Collections.Generic;
+
+  public class DefaultDictionary<TKey, TValue> : ImmutableDictionary<TKey, TValue> {
+    public readonly TValue defaultValue;
+    
+    public DefaultDictionary(TValue defaultValue, ImmutableDictionary<TKey, TValue> dictionary) : base(dictionary) {
+      this.defaultValue = defaultValue;
+    }
+
+    public DefaultDictionary(DefaultDictionary<TKey, TValue> dictionary, TKey key, TValue value) : base(dictionary, key, value) {
+      this.defaultValue = dictionary.defaultValue;
+    }
+
+    public new TValue this[TKey key] {
+      get {
+        return this.GetOrDefault(key, defaultValue);
+      }
+    }
+
+    public new DefaultDictionary<TKey, TValue> With(TKey key, TValue value)
+      => new DefaultDictionary<TKey, TValue>(this, key, value);
+  }
+
+  public static class DefaultDictionaryExtensionMethods {
+    public static DefaultDictionary<UKey, UValue> ToDefaultDictionary<T, UKey, UValue>(this IEnumerable<T> e, UValue defaultValue, Func<T, UKey> key, Func<T, UValue> value)
+      => new DefaultDictionary<UKey, UValue>(defaultValue, e.ToImmutableDictionary(key, value));
+  }
+//}

Utils/Immutable/Dictionary.cs

@@ -0,0 +1,71 @@
+//namespace Immutable {
+  using System;
+  using System.Linq;
+  using System.Collections.Generic;
+  using System.Collections;
+  using Mutable = System.Collections.Generic;
+  using Microsoft.FSharp.Collections;
+  using System.Collections.Immutable;
+
+  // TODO: use Microsoft.FSharp.Collections.FSharpMap
+  public class ImmutableDictionary<TKey, TValue> : Mutable.IReadOnlyDictionary<TKey, TValue> {
+    private readonly Mutable.Dictionary<TKey, TValue> d;
+    private System.Collections.Immutable.ImmutableDictionary<TKey, TValue> i = System.Collections.Immutable.ImmutableDictionary<TKey, TValue>.Empty;
+    //private readonly FSharpMap<TKey, TValue> x = new FSharpMap<int, int>(Enumerable.Enpty<Tuple<int, int>>());
+
+    public ImmutableDictionary() {
+      d = new Mutable.Dictionary<TKey, TValue>();
+    }
+
+    public ImmutableDictionary(Mutable.Dictionary<TKey, TValue> d) {
+      // Clone the mutable dictionary.
+      this.d = new Mutable.Dictionary<TKey, TValue>(d, d.Comparer);
+    }
+
+    public ImmutableDictionary(ImmutableDictionary<TKey, TValue> immutableDictionary, TKey key, TValue value) {
+      // Clone the mutable dictionary contained within that immutable
+      // dictionary before updating it.
+      var clone = new Mutable.Dictionary<TKey, TValue>(immutableDictionary.d, immutableDictionary.d.Comparer);
+      clone.Add(key, value);
+      this.d = clone;
+    }
+
+    public ImmutableDictionary(ImmutableDictionary<TKey, TValue> immutableDictionary) {
+      // No need to clone the mutable dictionary contained within
+      // that immutable dictionary, since we know it is never mutated.
+      this.d = immutableDictionary.d;
+    }
+
+    public TValue this[TKey key] { get => d[key]; }
+
+    public IEnumerable<TKey> Keys { get => d.Keys; }
+    public IEnumerable<TValue> Values { get => d.Values; }
+    public int Count { get => d.Count; }
+    public IEqualityComparer<TKey> Comparer { get => d.Comparer; }
+
+    public bool TryGetValue(TKey key, out TValue value)
+      => d.TryGetValue(key, out value);
+
+    public bool ContainsKey(TKey key)
+      => d.ContainsKey(key);
+
+    public ImmutableDictionary<TKey, TValue> With(TKey key, TValue value)
+      => new ImmutableDictionary<TKey, TValue>(this, key, value);
+
+    IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
+      => d.GetEnumerator();
+
+    IEnumerator IEnumerable.GetEnumerator()
+      => d.GetEnumerator();
+  }
+
+  public static class ImmutableDictionaryExtensionMethods {
+    public static ImmutableDictionary<UKey, UValue> ToImmutableDictionary<T, UKey, UValue>(this IEnumerable<T> e, Func<T, UKey> key, Func<T, UValue> value)
+      => new ImmutableDictionary<UKey, UValue>(e.ToDictionary(key, value));
+  }
+
+  // Prevent usage of the mutable dictionary.
+  public abstract class Dictionary<TKey, TValue> : ImmutableDictionary<TKey, TValue> {
+  }
+
+//}

main.cs

@@ -81,7 +81,7 @@ public static class MainClass {
       }
     } catch (UserErrorException e) {
       Console.WriteLine("");
-      Console.WriteLine(e.Message);
+      Console.WriteLine($"\x1b[1;33m{e.Message}\x1b[m\n");
       Environment.Exit(1);
     }
   }