draft for the parser
This commit is contained in:
Suzanne Soy
parent
139ed61fcd
commit
90e9a53107
29
Lexer.cs
29
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}"
|
||||
);
|
||||
|
|
|
|||
|
|
@ -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"),
|
||||
|
|
|
|||
10
Makefile
10
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, $^)
|
||||
|
|
|
|||
106
MixFix.cs
106
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<Grammar> xs) {
|
||||
public static Grammar1 Sequence(IEnumerable<Grammar1> 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<Grammar> xs) {
|
||||
public static Grammar1 Or(IEnumerable<Grammar1> 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<Grammar1>());
|
||||
|
||||
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<Operator> operators)
|
||||
=> Grammar.Or(
|
||||
operators.Select(@operator => @operator.ToGrammar()));
|
||||
public static Grammar1 ToGrammar1(this IEnumerable<Operator> 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<string, Grammar> DAGToGrammar(PrecedenceDAG precedenceDAG)
|
||||
=> precedenceDAG.ToImmutableDictionary(
|
||||
public static EquatableDictionary<string, Grammar1> ToGrammar1(this PrecedenceDAG precedenceDAG)
|
||||
=> precedenceDAG.ToEquatableDictionary(
|
||||
node => node.Key,
|
||||
node => node.Value.ToGrammar());
|
||||
node => node.Value.ToGrammar1());
|
||||
|
||||
private static Grammar2 Recur(Func<Grammar1, EquatableDictionary<string, Grammar1>, Grammar2> recur, Grammar1 grammar1, EquatableDictionary<string, Grammar1> labeled)
|
||||
=> grammar1.Match<Grammar2>(
|
||||
// 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<string, Grammar1> labeled)
|
||||
=> Func.YMemoize<Grammar1, EquatableDictionary<string, Grammar1>, Grammar2>(Recur)(Grammar1.Rule("program"), labeled);
|
||||
|
||||
public static Grammar2 ToGrammar2(this PrecedenceDAG precedenceDAG)
|
||||
=> precedenceDAG.ToGrammar1().ToGrammar2();
|
||||
}
|
||||
|
|
@ -12,13 +12,22 @@ public static class ParserGenerator {
|
|||
"}",
|
||||
"MixFix.",
|
||||
Types(
|
||||
Variant("Grammar",
|
||||
Case("Grammar", "RepeatOnePlus"),
|
||||
Case("IEnumerable<Grammar>", "Or"),
|
||||
Case("IEnumerable<Grammar>", "Sequence"),
|
||||
// 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<Grammar1>", "Or"),
|
||||
Case("IEnumerable<Grammar1>", "Sequence"),
|
||||
Case("S", "Terminal"),
|
||||
Case("string", "Rule")),
|
||||
|
||||
Variant("Grammar2",
|
||||
Case("Grammar2", "RepeatOnePlus"),
|
||||
Case("IEnumerable<Grammar2>", "Or"),
|
||||
Case("IEnumerable<Grammar2>", "Sequence"),
|
||||
Case("S", "Terminal")),
|
||||
|
||||
Variant("Fixity",
|
||||
Case("Closed"),
|
||||
Case("InfixLeftAssociative"),
|
||||
|
|
|
|||
79
Parser.cs
79
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<A> BindFold<T, A>(this IEnumerable<T> e, A init, Func<A, T, Option<A>> f) {
|
||||
var acc = init;
|
||||
foreach (var x in e) {
|
||||
var @new = f(acc, x);
|
||||
if (@new.IsNone) {
|
||||
return Option.None<A>();
|
||||
} else {
|
||||
acc = @new.ElseThrow(() => new Exception("impossible"));
|
||||
}
|
||||
}
|
||||
return acc.Some();
|
||||
}
|
||||
|
||||
public static A WhileSome<A>(A init, Func<A, Option<A>> 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<ImmutableEnumerator<Lexeme>> Parse3(
|
||||
Func<Grammar2,
|
||||
ImmutableEnumerator<Lexeme>,
|
||||
Option<ImmutableEnumerator<Lexeme>>>
|
||||
Parse3,
|
||||
Grammar2 grammar,
|
||||
ImmutableEnumerator<Lexeme> tokens
|
||||
) =>
|
||||
tokens
|
||||
.MoveNext()
|
||||
.Match<Tuple<Lexeme, ImmutableEnumerator<Lexeme>>, Option<ImmutableEnumerator<Lexeme>>>(
|
||||
None: () =>
|
||||
throw new Exception("EOF, what to do?"),
|
||||
Some: headRest => {
|
||||
throw new Exception("NIY");
|
||||
var first = headRest.Item1;
|
||||
var rest = headRest.Item2;
|
||||
grammar.Match<Option<ImmutableEnumerator<Lexeme>>>(
|
||||
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<ImmutableEnumerator<Lexeme>>()
|
||||
);
|
||||
// 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(
|
||||
|
|
@ -51,3 +126,5 @@ 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.
|
||||
|
||||
// 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).
|
||||
|
|
@ -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<string> 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}"))
|
||||
+ ");");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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<string> 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<string> w, string qualifier, string name, string C, string Ty) {
|
||||
|
|
@ -126,7 +135,9 @@ public static class VariantGenerator {
|
|||
}
|
||||
|
||||
private static void CaseAs(this Action<string> 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<string> w, string qualifier, string name, string C, string Ty) {
|
||||
|
|
@ -135,19 +146,11 @@ public static class VariantGenerator {
|
|||
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($" => 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<string> w, string qualifier, string name, Variant variant) {
|
||||
|
|
|
|||
|
|
@ -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>(T a, Object b, Func<Object, T> cast, params Func<T, Object>[] fieldAccessors) {
|
||||
if (Object.ReferenceEquals(a, null)) {
|
||||
public static bool Untyped<T>(T a, Object b, Func<Object, T> cast, Func<T, int> hashCode, params Func<T, T, bool>[] 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)) {
|
||||
if (hashCode(a) != hashCode(castB)) {
|
||||
return false;
|
||||
} else {
|
||||
return aFieldValue.Equals(bFieldValue);
|
||||
foreach (var comparer in comparers) {
|
||||
if (!comparer(a, castB)) {
|
||||
return false;
|
||||
} else {
|
||||
// continue.
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public static bool Untyped<T>(T a, Object b, Func<Object, T> cast, Func<T, int> hashCode, params Func<T, Object>[] fieldAccessors)
|
||||
=> Untyped<T>(
|
||||
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>(T a, Object b, Func<Object, T> cast, Func<T, int> hashCode)
|
||||
=> Untyped<T>(a, b, cast, hashCode, (aa, bb) => true);
|
||||
|
||||
// T must be the exact type of the receiver object whose
|
||||
// IEquatable<U>.Equals(U other) method is invoking
|
||||
// Equatable(this, other).
|
||||
public static bool Equatable<T>(T a, Object b) where T : IEquatable<T> {
|
||||
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;
|
||||
|
|
|
|||
|
|
@ -29,16 +29,45 @@ public static class Func {
|
|||
return a => b => c => f(a, b, c);
|
||||
}
|
||||
|
||||
public static Func<A, B> Memoize<A, B>(this Func<A, B> f) where A : IEquatable<A> {
|
||||
public static Func<A, B> YMemoize<A, B>(this Func<Func<A, B>, A, B> f) where A : IEquatable<A> {
|
||||
var d = new Mutable.Dictionary<A, B>();
|
||||
return a => {
|
||||
// I'm too lazy to implement the Y combinator…
|
||||
Func<A, B> 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<A, B, C> YMemoize<A, B, C>(this Func<Func<A, B, C>, A, B, C> f) where A : IEquatable<A> where B : IEquatable<B>
|
||||
=> (a, b) => YMemoize<ValueTuple<A, B>, C>(
|
||||
(memf, ab) =>
|
||||
f((aa, bb) => memf((aa, bb)),
|
||||
ab.Item1,
|
||||
ab.Item2))
|
||||
((a, b));
|
||||
|
||||
public static Func<A, B> Memoize<A, B>(this Func<A, B> f) where A : IEquatable<A>
|
||||
=> YMemoize<A, B>((memf, aa) => f(aa));
|
||||
|
||||
public static Func<A, B, C> Memoize<A, B, C>(this Func<A, B, C> f) where A : IEquatable<A> where B : IEquatable<B>
|
||||
=> YMemoize<A, B, C>((memf, aa, bb) => f(aa, bb));
|
||||
|
||||
public static B Memoized<A, B>(this Func<A, B> f, A a) where A : IEquatable<A>
|
||||
=> f.Memoize()(a);
|
||||
|
||||
public static C Memoized<A, B, C>(this Func<A, B, C> f, A a, B b) where A : IEquatable<A> where B : IEquatable<B>
|
||||
=> f.Memoize()(a, b);
|
||||
|
||||
public static B YMemoized<A, B>(this Func<Func<A, B>, A, B> f, A a) where A : IEquatable<A>
|
||||
=> f.YMemoize()(a);
|
||||
|
||||
public static C YMemoized<A, B, C>(this Func<Func<A, B, C>, A, B, C> f, A a, B b) where A : IEquatable<A> where B : IEquatable<B>
|
||||
=> f.YMemoize()(a, b);
|
||||
}
|
||||
|
|
@ -20,4 +20,6 @@ public static class Global {
|
|||
|
||||
public static ImmutableHashSet<T> ImmutableHashSet<T>(params T[] xs)
|
||||
=> xs.ToImmutableHashSet();
|
||||
|
||||
public static T To<T>(this T x) => x;
|
||||
}
|
||||
|
|
@ -2,7 +2,7 @@ namespace Immutable {
|
|||
using System;
|
||||
|
||||
public interface Option<out T> : System.Collections.Generic.IEnumerable<T> {
|
||||
U Match_<U>(Func<T, U> some, Func<U> none);
|
||||
U Match_<U>(Func<T, U> Some, Func<U> None);
|
||||
bool IsSome { get; }
|
||||
bool IsNone { get; }
|
||||
}
|
||||
|
|
@ -49,31 +49,39 @@ namespace Immutable {
|
|||
public static class OptionExtensionMethods {
|
||||
public static Option<T> Some<T>(this T value) => Option.Some<T>(value);
|
||||
|
||||
public static U Match<T, U>(this Option<T> o, Func<T, U> some, Func<U> none)
|
||||
=> o.Match_(some, none);
|
||||
public static U Match<T, U>(this Option<T> o, Func<T, U> Some, Func<U> None)
|
||||
=> o.Match_(Some: Some,
|
||||
None: None);
|
||||
|
||||
public static U Match<T, U>(this Option<T> o, Func<T, U> some, U none)
|
||||
=> o.Match_(some, () => none);
|
||||
public static U Match<T, U>(this Option<T> o, Func<T, U> Some, U None)
|
||||
=> o.Match_(Some: Some,
|
||||
None: () => None);
|
||||
|
||||
public static Option<U> Map<T, U>(this Option<T> o, Func<T, U> some)
|
||||
=> o.Match_(value => some(value).Some(), () => Option.None<U>());
|
||||
=> o.Match_(Some: value => some(value).Some(),
|
||||
None: () => Option.None<U>());
|
||||
|
||||
public static Option<U> IfSome<T, U>(this Option<T> o, Func<T, U> some)
|
||||
=> o.Map(some);
|
||||
|
||||
public static Option<U> Bind<T, U>(this Option<T> o, Func<T, Option<U>> f)
|
||||
=> o.Match_(some => f(some), () => Option.None<U>());
|
||||
=> o.Match_(Some: some => f(some),
|
||||
None: () => Option.None<U>());
|
||||
|
||||
public static T Else<T>(this Option<T> o, Func<T> none)
|
||||
=> o.Match_(some => some, none);
|
||||
=> o.Match_(Some: some => some,
|
||||
None: none);
|
||||
|
||||
public static T Else<T>(this Option<T> o, T none)
|
||||
=> o.Match_(some => some, () => none);
|
||||
=> o.Match_(Some: some => some,
|
||||
None: () => none);
|
||||
|
||||
public static Option<T> Else<T>(this Option<T> o, Func<Option<T>> none)
|
||||
=> o.Match_(value => value.Some(), none);
|
||||
=> o.Match_(Some: value => value.Some(),
|
||||
None: none);
|
||||
|
||||
public static T ElseThrow<T>(this Option<T> o, Func<Exception> none)
|
||||
=> o.Match_(value => value, () => throw none());
|
||||
=> o.Match_(Some: value => value,
|
||||
None: () => throw none());
|
||||
}
|
||||
}
|
||||
|
|
@ -9,11 +9,12 @@ namespace Immutable {
|
|||
public static bool operator !=(Unit a, Unit b)
|
||||
=> !(a == b);
|
||||
public override bool Equals(object other)
|
||||
=> Equality.Untyped<Unit>(this, other, x => x as Unit);
|
||||
=> Equality.Untyped<Unit>(this, other, x => x as Unit, x => x.hashCode);
|
||||
public bool Equals(Unit other)
|
||||
=> Equality.Equatable<Unit>(this, other);
|
||||
private int hashCode = HashCode.Combine("Unit");
|
||||
public override int GetHashCode()
|
||||
=> HashCode.Combine("Unit");
|
||||
=> hashCode;
|
||||
public override string ToString() => "Unit";
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user