suzanne.soy/envlang-csharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use Immutable collections pretty much everywhere"

Browse Source
This commit is contained in:
Suzanne Soy 2020-08-20 00:42:04 +00:00
parent 799795ffab
commit b3d41496d5
8 changed files with 81 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Lexer.cs
View File

@ -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 =
Dict.ToDefaultDictionary(
public static ImmutableDefaultDictionary<S, List<Rule>> WithEpsilonTransitions =
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
.GetOrDefault(state, new List<Rule>());
var possibleNext = Rules.WithEpsilonTransitions[state];
yield return
possibleNext
.First(r => r.test(c))

6
Makefile
View File

@ -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 $<

26
ParserGenerator.cs
View File

@ -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("List<Parser.Grammar>", "Sequence")),
Case("ImmutableList<Parser.Grammar>", "Or"),
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("List<string>", "holes")),
Field("ImmutableList<S>", "parts"),
Field("ImmutableList<string>", "holes")),
Record("DAGNode",
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"))));
Field("ImmutableList<Operator>", "infixLeftAssociative"),
Field("ImmutableList<Operator>", "infixRightAssociative"),
Field("ImmutableList<Operator>", "infixNonAssociative"),
Field("ImmutableList<Operator>", "prefix"),
Field("ImmutableList<Operator>", "postfix"),
Field("ImmutableList<Operator>", "closed"),
Field("ImmutableList<Operator>", "terminal"),
Field("ImmutableList<string>", "successorNodes"))));
}
}

24
Utils/Enumerable.cs
View File

@ -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 ListI<Tuple<T,U>> Add<T,U>(this ListI<Tuple<T,U>> l, T x, U y)
=> l.Add(Tuple.Create(x,y));
*/
public static ImmutableList<T> Cons<T>(this ImmutableList<T> l, T x)
=> l.Add(x);
// System.Collections.Immutable requires NuGet and is not available on repl.it
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)
public static ImmutableList<Tuple<T,U>> Cons<T,U>(this ImmutableList<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);
}

13
Utils/Global.cs
View File

@ -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<T> None<T>() => Option.None<T>();
public static Immutable.Option<T> None<T>() => Immutable.Option.None<T>();
public static ImmutableList<T> ImmutableList<T>(params T[] xs)
=> xs.ToImmutableList();
}

35
Utils/Immutable/DefaultDictionary.cs
View File

@ -1,30 +1,33 @@
//namespace Immutable {
using System;
using System.Collections;
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 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.dictionary = dictionary;
}
public DefaultDictionary(DefaultDictionary<TKey, TValue> dictionary, TKey key, TValue value) : base(dictionary, key, value) {
this.defaultValue = dictionary.defaultValue;
public TValue this[TKey key] {
get => dictionary.GetOrDefault(key, defaultValue);
}
public new TValue this[TKey key] {
get {
return this.GetOrDefault(key, defaultValue);
}
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 new DefaultDictionary<TKey, TValue> With(TKey key, TValue value)
=> new DefaultDictionary<TKey, TValue>(this, key, value);
}
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 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));
public static ImmutableDefaultDictionary<TKey, TValue> ToImmutableDefaultDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue> d, TValue defaultValue)
=> new ImmutableDefaultDictionary<TKey, TValue>(defaultValue, d);
}
//}

2
Utils/Immutable/Dictionary.cs
View File

@ -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 @@
}
//}
*/

3
main.cs
View File

@ -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"));