From b3d41496d5ed090f75277164ab2bf2a1acf8f129 Mon Sep 17 00:00:00 2001 From: Suzanne Soy Date: Thu, 20 Aug 2020 00:42:04 +0000 Subject: [PATCH] Use Immutable collections pretty much everywhere" --- Lexer.cs | 22 +++++------ Makefile | 6 ++- ParserGenerator.cs | 26 ++++++------- Utils/Enumerable.cs | 24 +++++------- Utils/Global.cs | 13 +++++-- Utils/Immutable/DefaultDictionary.cs | 55 +++++++++++++++------------- Utils/Immutable/Dictionary.cs | 2 + main.cs | 3 +- 8 files changed, 81 insertions(+), 70 deletions(-) diff --git a/Lexer.cs b/Lexer.cs index c5fd0f7..bdc211f 100644 --- a/Lexer.cs +++ b/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 Default = new List { + public static ImmutableList 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> Dict = + public static ImmutableDefaultDictionary> Dict = Default .GroupBy(r => r.oldState, r => r) - .ToDefaultDictionary( + .ToImmutableDefaultDictionary( new List(), rs => rs.Key, rs => rs.ToList()) ; // This adds transitions through an implicit empty whitespace. - public static DefaultDictionary> WithEpsilonTransitions = - Dict.ToDefaultDictionary( + public static ImmutableDefaultDictionary> WithEpsilonTransitions = + Dict.ToImmutableDefaultDictionary( new List(), 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 - .GetOrDefault(state, new List()); + var possibleNext = Rules.WithEpsilonTransitions[state]; yield return possibleNext .First(r => r.test(c)) diff --git a/Makefile b/Makefile index fb72724..fa3b969 100644 --- a/Makefile +++ b/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 $< diff --git a/ParserGenerator.cs b/ParserGenerator.cs index 2c496b3..9cd5151 100644 --- a/ParserGenerator.cs +++ b/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", "Or"), - Case("List", "Sequence")), + Case("ImmutableList", "Or"), + Case("ImmutableList", "Sequence")), Variant("Fixity", Case("Closed"), @@ -25,17 +25,17 @@ public static class ParserGenerator { Record("Operator", Field("Fixity", "fixity"), - Field("List", "parts"), - Field("List", "holes")), + Field("ImmutableList", "parts"), + Field("ImmutableList", "holes")), Record("DAGNode", - Field("List", "infixLeftAssociative"), - Field("List", "infixRightAssociative"), - Field("List", "infixNonAssociative"), - Field("List", "prefix"), - Field("List", "postfix"), - Field("List", "closed"), - Field("List", "terminal"), - Field("List", "successorNodes")))); + Field("ImmutableList", "infixLeftAssociative"), + Field("ImmutableList", "infixRightAssociative"), + Field("ImmutableList", "infixNonAssociative"), + Field("ImmutableList", "prefix"), + Field("ImmutableList", "postfix"), + Field("ImmutableList", "closed"), + Field("ImmutableList", "terminal"), + Field("ImmutableList", "successorNodes")))); } } \ No newline at end of file diff --git a/Utils/Enumerable.cs b/Utils/Enumerable.cs index bb9b13c..0268baa 100644 --- a/Utils/Enumerable.cs +++ b/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(this IEnumerable x, Action f) - => x.ToList().ForEach(f); + => x.ToImmutableList().ForEach(f); - /* - public static ListI> Add(this ListI> l, T x, U y) - => l.Add(Tuple.Create(x,y)); - */ + public static ImmutableList Cons(this ImmutableList l, T x) + => l.Add(x); - // System.Collections.Immutable requires NuGet and is not available on repl.it - public static List Cons(this List 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> Cons(this List> l, T x, U y) + public static ImmutableList> Cons(this ImmutableList> l, T x, U y) => l.Cons(Tuple.Create(x,y)); - public static List> Cons(this List> l, T x, U y, V z) + public static ImmutableList> Cons(this ImmutableList> l, T x, U y, V z) => l.Cons(Tuple.Create(x,y,z)); public static void Deconstruct(this Tuple t, out A a, out B b) { @@ -169,4 +161,8 @@ public static class Collection { return defaultValue; } } + + public static string JoinWith(this IEnumerable strings, string joiner) + // TODO: use StringBuilder, there is no complexity info in the docs. + => String.Join(joiner, strings); } \ No newline at end of file diff --git a/Utils/Global.cs b/Utils/Global.cs index bb00f8b..bfcd0e1 100644 --- a/Utils/Global.cs +++ b/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) - => b.Append(s); + public static Option None() => Option.None(); - public static Immutable.Option None() => Immutable.Option.None(); + public static ImmutableList ImmutableList(params T[] xs) + => xs.ToImmutableList(); } \ No newline at end of file diff --git a/Utils/Immutable/DefaultDictionary.cs b/Utils/Immutable/DefaultDictionary.cs index 2eb3824..2d76399 100644 --- a/Utils/Immutable/DefaultDictionary.cs +++ b/Utils/Immutable/DefaultDictionary.cs @@ -1,30 +1,33 @@ -//namespace Immutable { - using System; - using System.Collections.Generic; +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.Immutable; - public class DefaultDictionary : ImmutableDictionary { - public readonly TValue defaultValue; - - public DefaultDictionary(TValue defaultValue, ImmutableDictionary dictionary) : base(dictionary) { - this.defaultValue = defaultValue; - } - - public DefaultDictionary(DefaultDictionary 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 With(TKey key, TValue value) - => new DefaultDictionary(this, key, value); +public class ImmutableDefaultDictionary : IEnumerable> { + public readonly TValue defaultValue; + public readonly ImmutableDictionary dictionary; + + public ImmutableDefaultDictionary(TValue defaultValue, ImmutableDictionary dictionary) { + this.defaultValue = defaultValue; + this.dictionary = dictionary; } - public static class DefaultDictionaryExtensionMethods { - public static DefaultDictionary ToDefaultDictionary(this IEnumerable e, UValue defaultValue, Func key, Func value) - => new DefaultDictionary(defaultValue, e.ToImmutableDictionary(key, value)); + public TValue this[TKey key] { + get => dictionary.GetOrDefault(key, defaultValue); } -//} \ No newline at end of file + + public ImmutableDefaultDictionary With(TKey key, TValue value) + => new ImmutableDefaultDictionary(defaultValue, dictionary.Add(key, value)); + + public IEnumerator> GetEnumerator() => dictionary.GetEnumerator(); + + IEnumerator IEnumerable.GetEnumerator() => dictionary.GetEnumerator(); +} + +public static class ImmutableDefaultDictionaryExtensionMethods { + public static ImmutableDefaultDictionary ToImmutableDefaultDictionary(this IEnumerable e, UValue defaultValue, Func key, Func value) + => new ImmutableDefaultDictionary(defaultValue, e.ToImmutableDictionary(key, value)); + + public static ImmutableDefaultDictionary ToImmutableDefaultDictionary(this ImmutableDictionary d, TValue defaultValue) + => new ImmutableDefaultDictionary(defaultValue, d); +} \ No newline at end of file diff --git a/Utils/Immutable/Dictionary.cs b/Utils/Immutable/Dictionary.cs index f8cf701..fcb4525 100644 --- a/Utils/Immutable/Dictionary.cs +++ b/Utils/Immutable/Dictionary.cs @@ -8,6 +8,7 @@ using System.Collections.Immutable; // TODO: use Microsoft.FSharp.Collections.FSharpMap + /* public class ImmutableDictionary : Mutable.IReadOnlyDictionary { private readonly Mutable.Dictionary d; private System.Collections.Immutable.ImmutableDictionary i = System.Collections.Immutable.ImmutableDictionary.Empty; @@ -69,3 +70,4 @@ } //} +*/ \ No newline at end of file diff --git a/main.cs b/main.cs index 1932a44..494f8cd 100644 --- a/main.cs +++ b/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; @@ -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>() + var compilers = ImmutableList>.Empty .Cons(" js ", Compilers.JS.Compile, Exe("node")) .Cons("eval", Evaluator.Evaluate, Exe("cat"));