Use Immutable collections pretty much everywhere"

Lexer.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Text;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using Immutable;
 using System.Globalization;
@@ -45,7 +46,7 @@ public static partial class Lexer {
            newState ?? throughState);
 
     private static Rule Rule(S oldState, char[] cs, S throughState, S newState = null) {
-      var csl = cs.Select(x => x.ToString()).ToList();
+      var csl = cs.Select(x => x.ToString()).ToImmutableList();
       return new Rule(
         oldState,
         ", ".Join(cs.Select(CharDescription)),
@@ -55,7 +56,7 @@ public static partial class Lexer {
     }
 
     public static EOF EOF = new EOF();
-    public static List<Rule> Default = new List<Rule> {
+    public static ImmutableList<Rule> Default = ImmutableList(
       Rule(S.Space,   C.DecimalDigitNumber, S.Int),
       Rule(S.Space,   C.SpaceSeparator,     S.Space),
       Rule(S.Space,   EOF,                  S.End),
@@ -69,20 +70,20 @@ public static partial class Lexer {
       Rule(S.String,  C.LowercaseLetter,    S.String),
       Rule(S.String,  C.UppercaseLetter,    S.String),
       Rule(S.String,  C.DecimalDigitNumber, S.String),
-      Rule(S.String,  '"',                  S.StringClose, S.Space),
+      Rule(S.String,  '"',                  S.StringClose, S.Space)
-    };
+    );
 
-    public static DefaultDictionary<S, List<Rule>> Dict =
+    public static ImmutableDefaultDictionary<S, List<Rule>> Dict =
       Default
         .GroupBy(r => r.oldState, r => r)
-        .ToDefaultDictionary(
+        .ToImmutableDefaultDictionary(
           new List<Rule>(),
           rs => rs.Key,
           rs => rs.ToList()) ;
 
     // This adds transitions through an implicit empty whitespace.
-    public static DefaultDictionary<S, List<Rule>> WithEpsilonTransitions =
+    public static ImmutableDefaultDictionary<S, List<Rule>> WithEpsilonTransitions =
-      Dict.ToDefaultDictionary(
+      Dict.ToImmutableDefaultDictionary(
         new List<Rule>(),
         kv => kv.Key,
         kv => kv.Value.Any(r => true) // r.test(" ")
@@ -128,7 +129,7 @@ public static partial class Lexer {
         .SingleUseEnumerable()
         .TakeUntil(c => c.str.StartsWith("\n"))
         .Select(c => c.str)
-        .Aggregate(new StringBuilder(), Append);
+        .JoinWith("");
 
     var expected = ", ".Join(possibleNext.Select(p => p.description));
     var actual = (gc.endOfFile ? "" : "grapheme cluster ") + gc.Description();
@@ -152,8 +153,7 @@ public static partial class Lexer {
     while (e.MoveNext()) {
       var c = e.Current;
       context.Append(c.str);
-      var possibleNext = Rules.WithEpsilonTransitions
+      var possibleNext = Rules.WithEpsilonTransitions[state];
-                           .GetOrDefault(state, new List<Rule>());
       yield return
         possibleNext
           .First(r => r.test(c))

Makefile

@@ -7,7 +7,11 @@ run: main.exe
 	MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ mono main.exe
 
 main.exe: $(sort $(CS) $(GENERATED))
-	mcs -out:$@ -sdk:45 /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 $^
+	mcs -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 \
+   $^
 
 %Generated.cs: .%Generator.exe
 	mono $<

ParserGenerator.cs

@@ -4,15 +4,15 @@ public static class ParserGenerator {
   public static void Main() {
     Generate(
       "ParserGenerated.cs",
-        "using System.Collections.Generic;\n"
+        "using System.Collections.Immutable;\n"
       + "using S = Lexer.S;",
       "public static partial class Parser {",
       "}",
       "Parser.",
       Types(
         Variant("Grammar",
-          Case("List<Parser.Grammar>", "Or"),
+          Case("ImmutableList<Parser.Grammar>", "Or"),
-          Case("List<Parser.Grammar>", "Sequence")),
+          Case("ImmutableList<Parser.Grammar>", "Sequence")),
 
         Variant("Fixity",
           Case("Closed"),
@@ -25,17 +25,17 @@ public static class ParserGenerator {
 
         Record("Operator",
           Field("Fixity", "fixity"),
-          Field("List<S>", "parts"),
+          Field("ImmutableList<S>", "parts"),
-          Field("List<string>", "holes")),
+          Field("ImmutableList<string>", "holes")),
 
         Record("DAGNode",
-          Field("List<Operator>", "infixLeftAssociative"),
+          Field("ImmutableList<Operator>", "infixLeftAssociative"),
-          Field("List<Operator>", "infixRightAssociative"),
+          Field("ImmutableList<Operator>", "infixRightAssociative"),
-          Field("List<Operator>", "infixNonAssociative"),
+          Field("ImmutableList<Operator>", "infixNonAssociative"),
-          Field("List<Operator>", "prefix"),
+          Field("ImmutableList<Operator>", "prefix"),
-          Field("List<Operator>", "postfix"),
+          Field("ImmutableList<Operator>", "postfix"),
-          Field("List<Operator>", "closed"),
+          Field("ImmutableList<Operator>", "closed"),
-          Field("List<Operator>", "terminal"),
+          Field("ImmutableList<Operator>", "terminal"),
-          Field("List<string>", "successorNodes"))));
+          Field("ImmutableList<string>", "successorNodes"))));
   }
 }

Utils/Enumerable.cs

@@ -1,28 +1,20 @@
 using System;
 using System.Linq;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using Immutable;
 
 public static class Collection {
   public static void ForEach<T>(this IEnumerable<T> x, Action<T> f)
-    => x.ToList().ForEach(f);
+    => x.ToImmutableList().ForEach(f);
 
-  /*
+  public static ImmutableList<T> Cons<T>(this ImmutableList<T> l, T x)
-  public static ListI<Tuple<T,U>> Add<T,U>(this ListI<Tuple<T,U>> l, T x, U y)
+    => l.Add(x);
-    => l.Add(Tuple.Create(x,y));
-  */
 
-  // System.Collections.Immutable requires NuGet and is not available on repl.it
+  public static ImmutableList<Tuple<T,U>> Cons<T,U>(this ImmutableList<Tuple<T,U>> l, T x, U y)
-  public static List<T> Cons<T>(this List<T> l, T x) { l.Add(x); return l; }
-
-  // Circumvent bug with collection initializers, tuples and
-  // first-class functions by using repeated .Add()
-  // See https://repl.it/@suzannesoy/WarlikeWorstTraining#main.cs
-
-  public static List<Tuple<T,U>> Cons<T,U>(this List<Tuple<T,U>> l, T x, U y)
     => l.Cons(Tuple.Create(x,y));
 
-  public static List<Tuple<T,U,V>> Cons<T,U,V>(this List<Tuple<T,U,V>> l, T x, U y, V z)
+  public static ImmutableList<Tuple<T,U,V>> Cons<T,U,V>(this ImmutableList<Tuple<T,U,V>> l, T x, U y, V z)
     => l.Cons(Tuple.Create(x,y,z));
 
   public static void Deconstruct<A, B>(this Tuple<A, B> t, out A a, out B b) {
@@ -169,4 +161,8 @@ public static class Collection {
       return defaultValue;
     }
   }
+
+  public static string JoinWith(this IEnumerable<string> strings, string joiner)
+    // TODO: use StringBuilder, there is no complexity info in the docs.
+    => String.Join(joiner, strings);
 }

Utils/Global.cs

@@ -1,13 +1,18 @@
+using System;
+using System.Text;
+using System.Collections.Immutable;
+using Immutable;
+
 public static class Global {
   public static File File(string str) => new File(str);
   public static Ext  Ext (string str) => new Ext (str);
   public static Dir  Dir (string str) => new Dir (str);
   public static Exe  Exe (string str) => new Exe (str);
   
-  public static void Log (string str) => System.Console.WriteLine(str);
+  public static void Log (string str) => Console.WriteLine(str);
 
-  public static System.Text.StringBuilder Append(System.Text.StringBuilder b, string s)
+  public static Option<T> None<T>() => Option.None<T>();
-    => b.Append(s);
 
-  public static Immutable.Option<T> None<T>() => Immutable.Option.None<T>();
+  public static ImmutableList<T> ImmutableList<T>(params T[] xs)
+    => xs.ToImmutableList();
 }

Utils/Immutable/DefaultDictionary.cs

@@ -1,30 +1,33 @@
-//namespace Immutable {
+using System;
-  using System;
+using System.Collections;
-  using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Collections.Immutable;
 
-  public class DefaultDictionary<TKey, TValue> : ImmutableDictionary<TKey, TValue> {
+public class ImmutableDefaultDictionary<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>> {
-    public readonly TValue defaultValue;
+  public readonly TValue defaultValue;
+  public readonly ImmutableDictionary<TKey, TValue> dictionary;
   
-    public DefaultDictionary(TValue defaultValue, ImmutableDictionary<TKey, TValue> dictionary) : base(dictionary) {
+  public ImmutableDefaultDictionary(TValue defaultValue, ImmutableDictionary<TKey, TValue> dictionary) {
-      this.defaultValue = defaultValue;
+    this.defaultValue = defaultValue;
-    }
+    this.dictionary = dictionary;
-
-    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 TValue this[TKey key] {
-    public static DefaultDictionary<UKey, UValue> ToDefaultDictionary<T, UKey, UValue>(this IEnumerable<T> e, UValue defaultValue, Func<T, UKey> key, Func<T, UValue> value)
+    get => dictionary.GetOrDefault(key, defaultValue);
-      => new DefaultDictionary<UKey, UValue>(defaultValue, e.ToImmutableDictionary(key, value));
   }
-//}
+
+  public ImmutableDefaultDictionary<TKey, TValue> With(TKey key, TValue value)
+    => new ImmutableDefaultDictionary<TKey, TValue>(defaultValue, dictionary.Add(key, value));
+
+  public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator() => dictionary.GetEnumerator();
+
+  IEnumerator IEnumerable.GetEnumerator() => dictionary.GetEnumerator();
+}
+
+public static class ImmutableDefaultDictionaryExtensionMethods {
+  public static ImmutableDefaultDictionary<UKey, UValue> ToImmutableDefaultDictionary<T, UKey, UValue>(this IEnumerable<T> e, UValue defaultValue, Func<T, UKey> key, Func<T, UValue> value)
+    => new ImmutableDefaultDictionary<UKey, UValue>(defaultValue, e.ToImmutableDictionary(key, value));
+
+  public static ImmutableDefaultDictionary<TKey, TValue> ToImmutableDefaultDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue> d, TValue defaultValue)
+    => new ImmutableDefaultDictionary<TKey, TValue>(defaultValue, d);
+}

Utils/Immutable/Dictionary.cs

@@ -8,6 +8,7 @@
   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;
@@ -69,3 +70,4 @@
   }
 
 //}
+*/

main.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Linq;
 using SearchOption = System.IO.SearchOption;
 using Compiler = System.Func<Ast.Expr, string>;
@@ -42,7 +43,7 @@ public static class MainClass {
     // Circumvent bug with collection initializers, tuples and
     // first-class functions by using repeated .Add()
     // See https://repl.it/@suzannesoy/WarlikeWorstTraining#main.cs
-    var compilers = new List<Tuple<string, Compiler, Exe>>()
+    var compilers = ImmutableList<Tuple<string, Compiler, Exe>>.Empty
       .Cons(" js ", Compilers.JS.Compile, Exe("node"))
       .Cons("eval", Evaluator.Evaluate,   Exe("cat"));