From 90e9a5310781dbcff2075723e428864c258387fe Mon Sep 17 00:00:00 2001 From: Suzanne Soy Date: Fri, 28 Aug 2020 02:15:32 +0000 Subject: [PATCH] draft for the parser --- Lexer.cs | 29 +++++------ LexerGenerator.cs | 5 ++ Makefile | 10 ++-- MixFix.cs | 106 ++++++++++++++++++++++---------------- MixFixGenerator.cs | 21 +++++--- Parser.cs | 81 ++++++++++++++++++++++++++++- T4/RecordGenerator.cs | 16 +++--- T4/VariantGenerator.cs | 43 +++++++++------- Utils/Equality.cs | 53 ++++++++++++++----- Utils/Func.cs | 35 +++++++++++-- Utils/Global.cs | 2 + Utils/Immutable/Option.cs | 30 +++++++---- Utils/Immutable/Unit.cs | 5 +- 13 files changed, 307 insertions(+), 129 deletions(-) diff --git a/Lexer.cs b/Lexer.cs index bb04460..7e0b054 100644 --- a/Lexer.cs +++ b/Lexer.cs @@ -18,8 +18,10 @@ public static partial class Lexer { description: cat.ToString(), test: c => c.codePoints .First() - .Match(some: (x => x.UnicodeCategory(0) == cat), - none: false), + .Match( + Some: x => + x.UnicodeCategory(0) == cat, + None: false), throughState: throughState, newState: newState ?? throughState); @@ -40,8 +42,9 @@ public static partial class Lexer { description: CharDescription(c), test: x => x.codePoints .Single() - .Match(some: xx => xx == c.ToString(), - none: false), + .Match( + Some: xx => xx == c.ToString(), + None: false), throughState: throughState, newState: newState ?? throughState); @@ -52,7 +55,8 @@ public static partial class Lexer { description: ", ".Join(cs.Select(CharDescription)), test: x => x.codePoints .Single() - .Match(some: csl.Contains, none: false), + .Match(Some: csl.Contains, + None: false), throughState: throughState, newState: newState ?? throughState); } @@ -117,15 +121,8 @@ public static partial class Lexer { : kv.Value); } - public struct Lexeme { - public readonly S state; - // TODO: maybe keep this as a list of grapheme clusters - public readonly string lexeme; - public Lexeme(S state, string lexeme) { - this.state = state; - this.lexeme = lexeme; - } - public override string ToString() { + public partial class Lexeme { + private string CustomToString() { return $"new Lexeme({state}, \"{lexeme}\")"; } } @@ -158,8 +155,8 @@ public static partial class Lexer { var actual = (gc.endOfFile ? "" : "grapheme cluster ") + gc.Description(); var cat = gc.codePoints .First() - .Match(some: (x => x.UnicodeCategory(0).ToString()), - none: "None (empty string)"); + .Match(Some: x => x.UnicodeCategory(0).ToString(), + None: "None (empty string)"); return new ParserErrorException( $"Unexpected {actual} (Unicode category {cat}) while the lexer was in state {state}: expected one of {expected}{Environment.NewLine}{context} <--HERE {rest}" ); diff --git a/LexerGenerator.cs b/LexerGenerator.cs index b5dc2e0..58cf9bb 100644 --- a/LexerGenerator.cs +++ b/LexerGenerator.cs @@ -9,6 +9,11 @@ public static class LexerGenerator { "}", "Lexer.", Types( + Record("Lexeme", + Field("S", "state"), + // TODO: maybe keep the lexeme as a list of + // grapheme clusters + Field("string", "lexeme")), Variant("S", Case("End"), Case("Space"), diff --git a/Makefile b/Makefile index 359d707..621b413 100644 --- a/Makefile +++ b/Makefile @@ -8,16 +8,20 @@ run: main.exe Makefile MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ mono $< main.exe: $(CS) $(GENERATED) Makefile - mcs -debug+ -out:$@ \ + @echo 'Compiling…' + @mcs -debug+ -out:$@ \ /reference:/usr/lib/mono/4.5/System.Collections.Immutable.dll \ /reference:/usr/lib/mono/4.5/Facades/netstandard.dll \ $(filter-out Makefile, $^) %Generated.cs: .%Generator.exe Makefile - MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ mono $(filter-out Makefile, $<) + @echo 'Running code generator…' + @MONO_PATH=/usr/lib/mono/4.5/:/usr/lib/mono/4.5/Facades/ \ + mono $(filter-out Makefile, $<) .%Generator.exe: %Generator.cs $(META) Makefile - mcs -out:$@ \ + @echo 'Compiling code generator…' + @mcs -out:$@ \ /reference:/usr/lib/mono/4.5/System.Collections.Immutable.dll \ /reference:/usr/lib/mono/4.5/Facades/netstandard.dll \ $(filter-out Makefile, $^) diff --git a/MixFix.cs b/MixFix.cs index 60840bf..1846935 100644 --- a/MixFix.cs +++ b/MixFix.cs @@ -14,37 +14,37 @@ using static Global; using static MixFix.Fixity; public static partial class MixFix { - public partial class Grammar { - public static Grammar Sequence(params Grammar[] xs) + public partial class Grammar1 { + public static Grammar1 Sequence(params Grammar1[] xs) => Sequence(xs.ToImmutableList()); - public static Grammar Or(params Grammar[] xs) + public static Grammar1 Or(params Grammar1[] xs) => Or(xs.ToImmutableList()); - public static Grammar Sequence(IEnumerable xs) { + public static Grammar1 Sequence(IEnumerable xs) { var filteredXs = xs.Where(x => !x.IsEmpty); if (filteredXs.Count() == 1) { return filteredXs.Single().ElseThrow(() => new Exception("TODO: use an either to prove that this is safe.")); } else { - return new Grammar.Cases.Sequence(filteredXs); + return new Grammar1.Cases.Sequence(filteredXs); } } - public static Grammar Or(IEnumerable xs) { + public static Grammar1 Or(IEnumerable xs) { var filteredXs = xs.Where(x => !x.IsEmpty); if (filteredXs.Count() == 1) { return filteredXs.Single().ElseThrow(() => new Exception("TODO: use an either to prove that this is safe.")); } else { - return new Grammar.Cases.Or(filteredXs); + return new Grammar1.Cases.Or(filteredXs); } } - public static Grammar RepeatOnePlus(Grammar g) + public static Grammar1 RepeatOnePlus(Grammar1 g) => g.IsEmpty - ? Grammar.Empty - : new Grammar.Cases.RepeatOnePlus(g); + ? Grammar1.Empty + : new Grammar1.Cases.RepeatOnePlus(g); - public static Grammar Empty = new Grammar.Cases.Or(); + public static Grammar1 Empty = new Grammar1.Cases.Or(Enumerable.Empty()); public bool IsEmpty { get => this.Match( @@ -56,19 +56,19 @@ public static partial class MixFix { ); } - public static Grammar operator |(Grammar a, Grammar b) + public static Grammar1 operator |(Grammar1 a, Grammar1 b) => Or(a, b); - public static implicit operator Grammar((Grammar a, Grammar b) gs) + public static implicit operator Grammar1((Grammar1 a, Grammar1 b) gs) => Sequence(gs.a, gs.b); - public static implicit operator Grammar((Grammar a, Grammar b, Grammar c) gs) + public static implicit operator Grammar1((Grammar1 a, Grammar1 b, Grammar1 c) gs) => Sequence(gs.a, gs.b, gs.c); - public static bool operator true(Grammar g) => !g.IsEmpty; - public static bool operator false(Grammar g) => g.IsEmpty; + public static bool operator true(Grammar1 g) => !g.IsEmpty; + public static bool operator false(Grammar1 g) => g.IsEmpty; - public Grammar this[string multiplicity] { + public Grammar1 this[string multiplicity] { get { if (multiplicity != "+") { throw new Exception("Unexpected multiplicity"); @@ -296,7 +296,7 @@ public static partial class MixFix { public static PrecedenceDAG With(this PrecedenceDAG precedenceDAG, Operator @operator) { // This is where all the checks are done to ensure that the - // resulting grammar is well-formed and assuredly unambiguous. + // resulting grammar1 is well-formed and assuredly unambiguous. // Future extension idea: add an "ambiguous" keyword to // alleviate some restrictions. CheckLeftmostHole(precedenceDAG, @operator); @@ -316,47 +316,63 @@ public static partial class MixFix { associativity: associativity, parts: parts.ToImmutableList())); - public static Grammar ToGrammar(this Hole precedenceGroups) - => Grammar.Or( + public static Grammar1 ToGrammar1(this Hole precedenceGroups) + => Grammar1.Or( precedenceGroups.Select(precedenceGroup => - Grammar.Rule(precedenceGroup))); + Grammar1.Rule(precedenceGroup))); - public static Grammar ToGrammar(this Part part) + public static Grammar1 ToGrammar1(this Part part) => part.Match( - Name: name => Grammar.Terminal(name), - Hole: precedenceGroups => precedenceGroups.ToGrammar()); + Name: name => Grammar1.Terminal(name), + Hole: precedenceGroups => precedenceGroups.ToGrammar1()); - public static Grammar ToGrammar(this Operator @operator) - => Grammar.Sequence( - @operator.internalParts.Select(part => part.ToGrammar())); + public static Grammar1 ToGrammar1(this Operator @operator) + => Grammar1.Sequence( + @operator.internalParts.Select(part => part.ToGrammar1())); - public static Grammar ToGrammar(this IEnumerable operators) - => Grammar.Or( - operators.Select(@operator => @operator.ToGrammar())); + public static Grammar1 ToGrammar1(this IEnumerable operators) + => Grammar1.Or( + operators.Select(@operator => @operator.ToGrammar1())); - public static Grammar ToGrammar(this DAGNode node) { - var lsucc = node.leftmostHole_.ToGrammar(); - var rsucc = node.rightmostHole_.ToGrammar(); - var closed = node.closed.ToGrammar(); - var nonAssoc = node.infixNonAssociative.ToGrammar(); - var prefix = node.prefix.ToGrammar(); - var postfix = node.postfix.ToGrammar(); - var infixl = node.infixLeftAssociative.ToGrammar(); - var infixr = node.infixRightAssociative.ToGrammar(); + public static Grammar1 ToGrammar1(this DAGNode node) { + var lsucc = node.leftmostHole_.ToGrammar1(); + var rsucc = node.rightmostHole_.ToGrammar1(); + var closed = node.closed.ToGrammar1(); + var nonAssoc = node.infixNonAssociative.ToGrammar1(); + var prefix = node.prefix.ToGrammar1(); + var postfix = node.postfix.ToGrammar1(); + var infixl = node.infixLeftAssociative.ToGrammar1(); + var infixr = node.infixRightAssociative.ToGrammar1(); // TODO: BUG: only include these parts if there are // any operators with that fixity. return closed - | (nonAssoc ? (lsucc, nonAssoc, rsucc) : Grammar.Empty) + | (nonAssoc ? (lsucc, nonAssoc, rsucc) : Grammar1.Empty) // TODO: post-processsing of the leftassoc list. - | ((prefix || infixr) ? ((prefix | (lsucc, infixr))["+"], rsucc) : Grammar.Empty) + | ((prefix || infixr) ? ((prefix | (lsucc, infixr))["+"], rsucc) : Grammar1.Empty) // TODO: post-processsing of the leftassoc list. - | ((postfix || infixl) ? (lsucc, (postfix | (infixl, rsucc))["+"]) : Grammar.Empty); + | ((postfix || infixl) ? (lsucc, (postfix | (infixl, rsucc))["+"]) : Grammar1.Empty); } - public static ImmutableDictionary DAGToGrammar(PrecedenceDAG precedenceDAG) - => precedenceDAG.ToImmutableDictionary( + public static EquatableDictionary ToGrammar1(this PrecedenceDAG precedenceDAG) + => precedenceDAG.ToEquatableDictionary( node => node.Key, - node => node.Value.ToGrammar()); + node => node.Value.ToGrammar1()); + + private static Grammar2 Recur(Func, Grammar2> recur, Grammar1 grammar1, EquatableDictionary labeled) + => grammar1.Match( + // TODO: throw exception if lookup fails + Rule: r => recur(labeled[r], labeled), + Terminal: t => Grammar2.Terminal(t), + Sequence: l => Grammar2.Sequence(l.Select(g => recur(g, labeled))), + Or: l => Grammar2.Or(l.Select(g => recur(g, labeled))), + RepeatOnePlus: g => Grammar2.RepeatOnePlus(recur(g, labeled)) + ); + + public static Grammar2 ToGrammar2(this EquatableDictionary labeled) + => Func.YMemoize, Grammar2>(Recur)(Grammar1.Rule("program"), labeled); + + public static Grammar2 ToGrammar2(this PrecedenceDAG precedenceDAG) + => precedenceDAG.ToGrammar1().ToGrammar2(); } \ No newline at end of file diff --git a/MixFixGenerator.cs b/MixFixGenerator.cs index 96d1db0..36fe063 100644 --- a/MixFixGenerator.cs +++ b/MixFixGenerator.cs @@ -12,12 +12,21 @@ public static class ParserGenerator { "}", "MixFix.", Types( - Variant("Grammar", - Case("Grammar", "RepeatOnePlus"), - Case("IEnumerable", "Or"), - Case("IEnumerable", "Sequence"), - Case("S", "Terminal"), - Case("string", "Rule")), + // TODO: maybe instead of going through a + // Rule node we could just memoize the ToGrammar1 + // function, and attach an optional name to nodes + Variant("Grammar1", + Case("Grammar1", "RepeatOnePlus"), + Case("IEnumerable", "Or"), + Case("IEnumerable", "Sequence"), + Case("S", "Terminal"), + Case("string", "Rule")), + + Variant("Grammar2", + Case("Grammar2", "RepeatOnePlus"), + Case("IEnumerable", "Or"), + Case("IEnumerable", "Sequence"), + Case("S", "Terminal")), Variant("Fixity", Case("Closed"), diff --git a/Parser.cs b/Parser.cs index 3b6f7d5..e9db980 100644 --- a/Parser.cs +++ b/Parser.cs @@ -6,11 +6,86 @@ using System.Linq; using Immutable; using S = Lexer.S; using Lexeme = Lexer.Lexeme; +using Grammar2 = MixFix.Grammar2; using static Global; public static partial class Parser { + public static bool Parse2(string source) { + Grammar2 grammar = + DefaultGrammar.DefaultPrecedenceDAG.ToGrammar2(); + Log(grammar.Str()); + + // Parse3(grammar, Lexer.Lex(source)) + throw new NotImplementedException(); + } + + public static Option BindFold(this IEnumerable e, A init, Func> f) { + var acc = init; + foreach (var x in e) { + var @new = f(acc, x); + if (@new.IsNone) { + return Option.None(); + } else { + acc = @new.ElseThrow(() => new Exception("impossible")); + } + } + return acc.Some(); + } + + public static A WhileSome(A init, Func> f) { + var lastGood = init; + while (true) { + var @new = f(lastGood); + if (@new.IsNone) { + return lastGood; + } else { + lastGood = @new.ElseThrow(() => new Exception("impossible")); + } + } + } + + public static Option> Parse3( + Func, + Option>> + Parse3, + Grammar2 grammar, + ImmutableEnumerator tokens + ) => + tokens + .MoveNext() + .Match>, Option>>( + None: () => + throw new Exception("EOF, what to do?"), + Some: headRest => { + throw new Exception("NIY"); + var first = headRest.Item1; + var rest = headRest.Item2; + grammar.Match>>( + RepeatOnePlus: g => + Parse3(g, rest) + .IfSome(rest1 => + WhileSome(rest1, restI => Parse3(g, restI))), + // TODO: to check for ambiguous parses, we can use + // .SingleArg(…) instead of .FirstArg(…). + Or: l => + l.First(g => Parse3(g, rest)), + // TODO: use a shortcut version of .Aggregate + // to exit early when None is returned by a step + Sequence: l => + l.BindFold(rest, + (restI, g) => Parse3(g, restI)), + Terminal: t => + first.state.Equals(t) + ? rest.Some() + : None>() + ); + // TODO: at the top-level, check that the lexemes + // are empty if the parser won't accept anything else. + } + ); + public static Ast.Expr Parse(string source) { - Log(MixFix.DAGToGrammar(DefaultGrammar.DefaultPrecedenceDAG).Str()); return Lexer.Lex(source) .SelectMany(lexeme => lexeme.state.Match( @@ -50,4 +125,6 @@ public static partial class Parser { // -3 is recognized by the lexer, but -x is not allowed. Otherwise f -x is ambiguous, could be f (-x) or (f) - (x) -// relaxed unicity: the symbols must not appear in other operators of the same namespace nor as the closing bracket symbols which delimit the uses of this namespace in closed operators. Rationale: once the closing bracket is known, if the entire sub-expression doesn't include that bracket then the parser can fast-forward until the closing bracket, only caring about matching open and close symbols which may delimit sub-expressions with different namespaces, and know that whatever's inside is unambiguous. \ No newline at end of file +// relaxed unicity: the symbols must not appear in other operators of the same namespace nor as the closing bracket symbols which delimit the uses of this namespace in closed operators. Rationale: once the closing bracket is known, if the entire sub-expression doesn't include that bracket then the parser can fast-forward until the closing bracket, only caring about matching open and close symbols which may delimit sub-expressions with different namespaces, and know that whatever's inside is unambiguous. + +// Future: lex one by one to allow extending the grammar & lexer; when a new symbol is bound, re-start parsing from the start of the binding form and check that the parsing does find the same new binding at the same position. E.g. (a op b where "op" x y = x * y) is okay, but (a op b where "where" str = stuff) is not, because during the second pass, the unquoted where token does not produce a binding form anymore. E.g (a op b w/ "op" x y = x * y where "w/" = where) is okay, because during the first pass the w/ is treated as garbage, during the second pass it is treated as a binding form, but the where token which retroactively extended the grammar still parsed as the same grammar extension. In other words, re-parsing can rewrite part of the AST below the binding node, but the binding node itself should be at the same position (this includes the fact that it shouldn't be moved with respect to its ancestor AST nodes). \ No newline at end of file diff --git a/T4/RecordGenerator.cs b/T4/RecordGenerator.cs index d697c8a..3ec1a86 100644 --- a/T4/RecordGenerator.cs +++ b/T4/RecordGenerator.cs @@ -33,6 +33,10 @@ public static class RecordGenerator { var Ty = @field.Value; w($" this.{F} = {F};"); } + w($" this.hashCode = Equality.HashCode(\"{name}\","); + w(String.Join(",\n", record.Select(@field => + $" this.{@field.Key}"))); + w($" );"); w($" }}"); } @@ -42,17 +46,14 @@ public static class RecordGenerator { w($" public static bool operator !=({name} a, {name} b)"); w($" => !(a == b);"); w($" public override bool Equals(object other)"); - w($" => Equality.Untyped<{name}>(this, other, x => x as {name},"); + w($" => Equality.Untyped<{name}>(this, other, x => x as {name}, x => x.hashCode,"); w(String.Join(",\n", record.Select(@field => $" x => x.{@field.Key}"))); w($" );"); w($" public bool Equals({name} other)"); w($" => Equality.Equatable<{name}>(this, other);"); - w($" public override int GetHashCode()"); - w($" => Equality.HashCode(\"{name}\","); - w(String.Join(",\n", record.Select(@field => - $" this.{@field.Key}"))); - w($" );"); + w($" private readonly int hashCode;"); + w($" public override int GetHashCode() => hashCode;"); } private static void StringConversion(this Action w, string qualifier, string name, Record record) { @@ -69,7 +70,8 @@ public static class RecordGenerator { var noAtF = F.StartsWith("@") ? F.Substring(1) : F; var caseF = Char.ToUpper(noAtF[0]) + noAtF.Substring(1); var Ty = @field.Value; - w($" public {name} With{caseF}({Ty} {F}) => new {name}(" + w($" public {name} With{caseF}({Ty} {F})"); + w($" => new {name}(" + String.Join(", ", record.Select(@f => $"{f.Key}: {f.Key}")) + ");"); } diff --git a/T4/VariantGenerator.cs b/T4/VariantGenerator.cs index d7fb9d3..6a5639a 100644 --- a/T4/VariantGenerator.cs +++ b/T4/VariantGenerator.cs @@ -49,7 +49,9 @@ public static class VariantGenerator { var C = @case.Key; var Ty = @case.Value; // This method is overloaded by the corresponding case's class. - w($" public virtual Immutable.Option<{Ty == null ? "Immutable.Unit" : Ty}> As{C} {{ get => Immutable.Option.None<{Ty == null ? "Immutable.Unit" : Ty}>(); }}"); + w($" public virtual Immutable.Option<{Ty == null ? "Immutable.Unit" : Ty}> As{C} {{"); + w($" get => Immutable.Option.None<{Ty == null ? "Immutable.Unit" : Ty}>();"); + w($" }}"); } } @@ -106,7 +108,7 @@ public static class VariantGenerator { w($" public override string ToString()"); w($" => this.CustomToString();"); w($" private string CustomToString(params Immutable.Uninstantiatable[] _)"); - w($" => GetTag() + GetValue().Match(some: x => $\"({{x}})\", none: () => \"\");"); + w($" => GetTag() + GetValue().Match(Some: x => $\"({{x}})\", None: () => \"\");"); w($" public string Str() => this.ToString();"); } @@ -118,7 +120,14 @@ public static class VariantGenerator { } private static void CaseConstructor(this Action w, string qualifier, string name, string C, string Ty) { - w($" public {C}({Ty == null ? "" : $"{Ty} value"}) {{ {Ty == null ? "" : $"this.value = value; "}}}"); + w($" public {C}({Ty == null ? "" : $"{Ty} value"}) {{"); + w($" {Ty == null ? "" : $"this.value = value; "}"); + if (Ty == null) { + w($" this.hashCode = HashCode.Combine(\"{C}\");"); + } else { + w($" this.hashCode = HashCode.Combine(\"{C}\", this.value);"); + } + w($" }}"); } private static void CaseMatch_(this Action w, string qualifier, string name, string C, string Ty) { @@ -126,28 +135,22 @@ public static class VariantGenerator { } private static void CaseAs(this Action w, string qualifier, string name, string C, string Ty) { - w($" public override Immutable.Option<{Ty == null ? "Immutable.Unit" : Ty}> As{C} {{ get => Immutable.Option.Some<{Ty == null ? "Immutable.Unit" : Ty}>({Ty == null ? "Immutable.Unit.unit" : "this.value"}); }}"); + w($" public override Immutable.Option<{Ty == null ? "Immutable.Unit" : Ty}> As{C} {{"); + w($" get => Immutable.Option.Some<{Ty == null ? "Immutable.Unit" : Ty}>({Ty == null ? "Immutable.Unit.unit" : "this.value"});"); + w($" }}"); } private static void CaseEquality(this Action w, string qualifier, string name, string C, string Ty) { - w($" public static bool operator ==({C} a, {C} b)"); - w($" => Equality.Operator(a, b);"); - w($" public static bool operator !=({C} a, {C} b)"); - w($" => !(a == b);"); - w($" public override bool Equals(object other)"); - if (Ty == null) { - w($" => Equality.Untyped<{C}>(this, other, x => x as {C});"); - } else { - w($" => Equality.Untyped<{C}>(this, other, x => x as {C}, x => x.value);"); - } + w($" public static bool operator ==({C} a, {C} b)"); + w($" => Equality.Operator(a, b);"); + w($" public static bool operator !=({C} a, {C} b)"); + w($" => !(a == b);"); + w($" public override bool Equals(object other)"); + w($" => Equality.Untyped<{C}>(this, other, x => x as {C}, x => x.hashCode{(Ty == null) ? "" : ", x => x.value"});"); w($" public override bool Equals({name} other)"); w($" => Equality.Equatable<{name}>(this, other);"); - w($" public override int GetHashCode()"); - if (Ty == null) { - w($" => HashCode.Combine(\"{C}\");"); - } else { - w($" => HashCode.Combine(\"{C}\", this.value);"); - } + w($" private readonly int hashCode;"); + w($" public override int GetHashCode() => hashCode;"); } private static void Cases(this Action w, string qualifier, string name, Variant variant) { diff --git a/Utils/Equality.cs b/Utils/Equality.cs index 2958242..292e8ce 100644 --- a/Utils/Equality.cs +++ b/Utils/Equality.cs @@ -6,7 +6,9 @@ public static class Equality { // T can be any supertype of the instances passed to the == operator. public static bool Operator(Object a, Object b) { - if (Object.ReferenceEquals(a, null)) { + if (Object.ReferenceEquals(a, b)) { + return true; + } else if (Object.ReferenceEquals(a, null)) { return Object.ReferenceEquals(b, null); } else if (Object.ReferenceEquals(b, null)) { return false; @@ -18,8 +20,11 @@ public static class Equality { // T must be the exact type of the receiver object whose // Object.Equals(Object other) method is invoking // Untyped(this, other). - public static bool Untyped(T a, Object b, Func cast, params Func[] fieldAccessors) { - if (Object.ReferenceEquals(a, null)) { + public static bool Untyped(T a, Object b, Func cast, Func hashCode, params Func[] comparers) { + if (Object.ReferenceEquals(a, b)) { + // Short path when the two references are the same. + return true; + } else if (Object.ReferenceEquals(a, null)) { return Object.ReferenceEquals(b, null); } else if (Object.ReferenceEquals(b, null)) { return false; @@ -28,27 +33,47 @@ public static class Equality { if (Object.ReferenceEquals(castB, null)) { return false; } else { - foreach (var accessor in fieldAccessors) { - var aFieldValue = accessor(a); - var bFieldValue = accessor(castB); - if (Object.ReferenceEquals(aFieldValue, null)) { - return Object.ReferenceEquals(bFieldValue, null); - } else if (Object.ReferenceEquals(bFieldValue, null)) { - return false; - } else { - return aFieldValue.Equals(bFieldValue); + if (hashCode(a) != hashCode(castB)) { + return false; + } else { + foreach (var comparer in comparers) { + if (!comparer(a, castB)) { + return false; + } else { + // continue. + } } + return true; } - return true; } } } + public static bool Untyped(T a, Object b, Func cast, Func hashCode, params Func[] fieldAccessors) + => Untyped( + a, + b, + cast, + hashCode, + (aa, bb) => + fieldAccessors.All( + accessor => + Equality.Operator( + accessor(aa), + accessor(bb)))); + + // common method when there are no fields or comparers. + public static bool Untyped(T a, Object b, Func cast, Func hashCode) + => Untyped(a, b, cast, hashCode, (aa, bb) => true); + // T must be the exact type of the receiver object whose // IEquatable.Equals(U other) method is invoking // Equatable(this, other). public static bool Equatable(T a, Object b) where T : IEquatable { - if (Object.ReferenceEquals(a, null)) { + if (Object.ReferenceEquals(a, b)) { + // Short path when the two references are the same. + return true; + } else if (Object.ReferenceEquals(a, null)) { return Object.ReferenceEquals(b, null); } else if (Object.ReferenceEquals(b, null)) { return false; diff --git a/Utils/Func.cs b/Utils/Func.cs index 1add8ee..6fc41a5 100644 --- a/Utils/Func.cs +++ b/Utils/Func.cs @@ -29,16 +29,45 @@ public static class Func { return a => b => c => f(a, b, c); } - public static Func Memoize(this Func f) where A : IEquatable { + public static Func YMemoize(this Func, A, B> f) where A : IEquatable { var d = new Mutable.Dictionary(); - return a => { + // I'm too lazy to implement the Y combinator… + Func memf = null; + memf = a => { if (d.TryGetValue(a, out var b)) { return b; } else { - var calcB = f(a); + var calcB = f(memf, a); d.Add(a, calcB); return calcB; } }; + return memf; } + + public static Func YMemoize(this Func, A, B, C> f) where A : IEquatable where B : IEquatable + => (a, b) => YMemoize, C>( + (memf, ab) => + f((aa, bb) => memf((aa, bb)), + ab.Item1, + ab.Item2)) + ((a, b)); + + public static Func Memoize(this Func f) where A : IEquatable + => YMemoize((memf, aa) => f(aa)); + + public static Func Memoize(this Func f) where A : IEquatable where B : IEquatable + => YMemoize((memf, aa, bb) => f(aa, bb)); + + public static B Memoized(this Func f, A a) where A : IEquatable + => f.Memoize()(a); + + public static C Memoized(this Func f, A a, B b) where A : IEquatable where B : IEquatable + => f.Memoize()(a, b); + + public static B YMemoized(this Func, A, B> f, A a) where A : IEquatable + => f.YMemoize()(a); + + public static C YMemoized(this Func, A, B, C> f, A a, B b) where A : IEquatable where B : IEquatable + => f.YMemoize()(a, b); } \ No newline at end of file diff --git a/Utils/Global.cs b/Utils/Global.cs index 5b0311b..823e118 100644 --- a/Utils/Global.cs +++ b/Utils/Global.cs @@ -20,4 +20,6 @@ public static class Global { public static ImmutableHashSet ImmutableHashSet(params T[] xs) => xs.ToImmutableHashSet(); + + public static T To(this T x) => x; } \ No newline at end of file diff --git a/Utils/Immutable/Option.cs b/Utils/Immutable/Option.cs index 8a2d7e3..ef4b1bd 100644 --- a/Utils/Immutable/Option.cs +++ b/Utils/Immutable/Option.cs @@ -2,7 +2,7 @@ namespace Immutable { using System; public interface Option : System.Collections.Generic.IEnumerable { - U Match_(Func some, Func none); + U Match_(Func Some, Func None); bool IsSome { get; } bool IsNone { get; } } @@ -49,31 +49,39 @@ namespace Immutable { public static class OptionExtensionMethods { public static Option Some(this T value) => Option.Some(value); - public static U Match(this Option o, Func some, Func none) - => o.Match_(some, none); + public static U Match(this Option o, Func Some, Func None) + => o.Match_(Some: Some, + None: None); - public static U Match(this Option o, Func some, U none) - => o.Match_(some, () => none); + public static U Match(this Option o, Func Some, U None) + => o.Match_(Some: Some, + None: () => None); public static Option Map(this Option o, Func some) - => o.Match_(value => some(value).Some(), () => Option.None()); + => o.Match_(Some: value => some(value).Some(), + None: () => Option.None()); public static Option IfSome(this Option o, Func some) => o.Map(some); public static Option Bind(this Option o, Func> f) - => o.Match_(some => f(some), () => Option.None()); + => o.Match_(Some: some => f(some), + None: () => Option.None()); public static T Else(this Option o, Func none) - => o.Match_(some => some, none); + => o.Match_(Some: some => some, + None: none); public static T Else(this Option o, T none) - => o.Match_(some => some, () => none); + => o.Match_(Some: some => some, + None: () => none); public static Option Else(this Option o, Func> none) - => o.Match_(value => value.Some(), none); + => o.Match_(Some: value => value.Some(), + None: none); public static T ElseThrow(this Option o, Func none) - => o.Match_(value => value, () => throw none()); + => o.Match_(Some: value => value, + None: () => throw none()); } } \ No newline at end of file diff --git a/Utils/Immutable/Unit.cs b/Utils/Immutable/Unit.cs index 591673d..d82562c 100644 --- a/Utils/Immutable/Unit.cs +++ b/Utils/Immutable/Unit.cs @@ -9,11 +9,12 @@ namespace Immutable { public static bool operator !=(Unit a, Unit b) => !(a == b); public override bool Equals(object other) - => Equality.Untyped(this, other, x => x as Unit); + => Equality.Untyped(this, other, x => x as Unit, x => x.hashCode); public bool Equals(Unit other) => Equality.Equatable(this, other); + private int hashCode = HashCode.Combine("Unit"); public override int GetHashCode() - => HashCode.Combine("Unit"); + => hashCode; public override string ToString() => "Unit"; } } \ No newline at end of file