From b517d4f032f10fbe67f056fe23b19e78601d138f Mon Sep 17 00:00:00 2001 From: Suzanne Soy Date: Thu, 20 Aug 2020 19:57:54 +0000 Subject: [PATCH] This causes an internal error (null pointer exception) in mono when it tries to initialize the types --- Makefile | 2 +- Parser.cs | 24 +++++----- ParserGenerator.cs | 1 + Utils/Lens.cs | 33 +------------- Utils/Lens/ImmutableDictionaryLens.cs | 63 +++++++++++++++++++++++++++ Utils/Lens/ImmutableListLens.cs | 22 ++++++++++ Utils/Lens/LeafLens.cs | 16 +++++++ 7 files changed, 117 insertions(+), 44 deletions(-) create mode 100644 Utils/Lens/ImmutableDictionaryLens.cs create mode 100644 Utils/Lens/ImmutableListLens.cs create mode 100644 Utils/Lens/LeafLens.cs diff --git a/Makefile b/Makefile index 8c522c1..451ee5b 100644 --- a/Makefile +++ b/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 \ diff --git a/Parser.cs b/Parser.cs index 6f40cf2..1e118eb 100644 --- a/Parser.cs +++ b/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 {}; +using PrecedenceDAG = System.Collections.Immutable.ImmutableDictionary; +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) );*/ diff --git a/ParserGenerator.cs b/ParserGenerator.cs index 9cd5151..bacba9d 100644 --- a/ParserGenerator.cs +++ b/ParserGenerator.cs @@ -24,6 +24,7 @@ public static class ParserGenerator { Case("Terminal")), Record("Operator", + Field("string", "precedenceGroup"), Field("Fixity", "fixity"), Field("ImmutableList", "parts"), Field("ImmutableList", "holes")), diff --git a/Utils/Lens.cs b/Utils/Lens.cs index b778a60..1780f1d 100644 --- a/Utils/Lens.cs +++ b/Utils/Lens.cs @@ -7,35 +7,6 @@ public interface ILens { Whole Update(Func update); } -public sealed class ImmutableListLens : ILens, Whole> { - public readonly System.Func, Whole> wrap; - public readonly ImmutableList oldHole; - - public ImmutableListLens(System.Func, Whole> wrap, ImmutableList 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,Whole> sub-part => oldHole.sub-part.ChainLens(value => oldHole.with-sub-part(value)); - - public Whole Update(Func, ImmutableList> update) => wrap(update(oldHole)); -} - -// Lenses for primitive types and other types that are not -// interesting to further focus. -public sealed class LeafLens : ILens { - public readonly System.Func wrap; - public readonly T oldHole; - - public LeafLens(System.Func wrap, T oldHole) { - this.wrap = wrap; - this.oldHole = oldHole; - } - - public Whole Update(Func update) => wrap(update(oldHole)); -} - public static class LensExtensionMethods { public static Whole Update(this ILens lens, Hole newHole) => lens.Update(oldHole => newHole); @@ -59,6 +30,4 @@ public static class LensExtensionMethods { public LeafLens ChainLens(Func wrap) => new LeafLens(wrap: wrap, oldHole: value); } - - public static ILens, Whole> ChainLens(this ImmutableList hole, System.Func, Whole> wrap) => new ImmutableListLens(wrap: wrap, oldHole: hole); -} \ No newline at end of file +} diff --git a/Utils/Lens/ImmutableDictionaryLens.cs b/Utils/Lens/ImmutableDictionaryLens.cs new file mode 100644 index 0000000..4a48b90 --- /dev/null +++ b/Utils/Lens/ImmutableDictionaryLens.cs @@ -0,0 +1,63 @@ +using System; +using System.Collections.Immutable; + +public sealed class ImmutableDictionaryValueLens : ILens { + public readonly Func, Whole> wrap; + public readonly ImmutableDictionary oldDictionary; + public readonly TKey oldKey; + + public ImmutableDictionaryValueLens(Func, Whole> wrap, ImmutableDictionary 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,Whole> sub-part => oldHole.sub-part.ChainLens(value => oldHole.with-sub-part(value)); + + public Whole Update(Func update) { + var oldValue = oldDictionary[oldKey]; + return wrap(oldDictionary.SetItem(oldKey, update(oldValue))); + } + + public ImmutableDictionaryValueLens UpdateKey(Func update) { + var newKey = update(oldKey); + return new ImmutableDictionaryValueLens( + wrap, + oldDictionary.Remove(oldKey).Add(newKey, oldDictionary[oldKey]), + newKey); + } +} + +public sealed class ImmutableDictionaryLens : ILens, Whole> { + public readonly Func, Whole> wrap; + public readonly ImmutableDictionary oldHole; + + public ImmutableDictionaryLens(Func, Whole> wrap, ImmutableDictionary 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 this[TKey key] { + get => new ImmutableDictionaryValueLens(wrap, oldHole, key); + } + + public Whole Update(Func, ImmutableDictionary> update) { + return wrap(update(oldHole)); + } +} + +public static class ImmutableDictionaryLensExtensionMethods { + public static ImmutableDictionaryLens> lens(this ImmutableDictionary d) + => new ImmutableDictionaryLens>(x => x, d); + + public static ImmutableDictionaryValueLens UpdateKey(this ImmutableDictionaryValueLens lens, TKey newKey) + => lens.UpdateKey(oldKey => newKey); + + // This would need an IFocusable constraint which is hard to get + //public static ILens, Whole> ChainLens(this ImmutableDictionary hole, System.Func, Whole> wrap) + // => new ImmutableDictionaryLens(wrap: wrap, oldHole: hole); +} \ No newline at end of file diff --git a/Utils/Lens/ImmutableListLens.cs b/Utils/Lens/ImmutableListLens.cs new file mode 100644 index 0000000..118e2cb --- /dev/null +++ b/Utils/Lens/ImmutableListLens.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Immutable; + +public sealed class ImmutableListLens : ILens, Whole> { + public readonly Func, Whole> wrap; + public readonly ImmutableList oldHole; + + public ImmutableListLens(Func, Whole> wrap, ImmutableList 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,Whole> sub-part => oldHole.sub-part.ChainLens(value => oldHole.with-sub-part(value)); + + public Whole Update(Func, ImmutableList> update) => wrap(update(oldHole)); +} + +public static class ImmutableListLensExtensionMethods { + public static ILens, Whole> ChainLens(this ImmutableList hole, System.Func, Whole> wrap) + => new ImmutableListLens(wrap: wrap, oldHole: hole); +} \ No newline at end of file diff --git a/Utils/Lens/LeafLens.cs b/Utils/Lens/LeafLens.cs new file mode 100644 index 0000000..d079acc --- /dev/null +++ b/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 : ILens { + public readonly System.Func wrap; + public readonly T oldHole; + + public LeafLens(System.Func wrap, T oldHole) { + this.wrap = wrap; + this.oldHole = oldHole; + } + + public Whole Update(Func update) => wrap(update(oldHole)); +} \ No newline at end of file