From 829bff6c2b17cc4642856545d9b8e6870e4a7ab7 Mon Sep 17 00:00:00 2001 From: Suzanne Soy Date: Sun, 30 Aug 2020 22:39:01 +0000 Subject: [PATCH] Parser on immutable stream of lexemes, returns a rough representation of the AST --- AstGenerator.cs | 7 ++-- Parser.cs | 69 +++++++++++++++++++++++---------------- Utils/Enumerable.cs | 33 +++++++++++++++---- Utils/Global.cs | 8 ++--- Utils/Immutable/Option.cs | 9 +++++ Utils/Piping.cs | 1 + 6 files changed, 86 insertions(+), 41 deletions(-) diff --git a/AstGenerator.cs b/AstGenerator.cs index cd80590..1154fa6 100644 --- a/AstGenerator.cs +++ b/AstGenerator.cs @@ -4,13 +4,16 @@ public static class AstGenerator { public static void Main() { Generate( "AstGenerated.cs", - "", + "using System.Collections.Generic;", "namespace Ast {", "}", "Ast.", Types( Variant("Expr", Case("int", "Int"), - Case("string", "String")))); + Case("string", "String")), + Variant("AstNode", + Case("Expr", "Terminal"), + Case("IEnumerable", "Operator")))); } } \ No newline at end of file diff --git a/Parser.cs b/Parser.cs index e6a9ef9..cc363ea 100644 --- a/Parser.cs +++ b/Parser.cs @@ -4,61 +4,74 @@ using System.Collections.Generic; using System.Collections.Immutable; using System.Linq; using Immutable; +using Ast; 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> Parse3( - Func, - Option>> + public static Option, AstNode>> Parse3( + Func, + Grammar2, + //Option> + Option, AstNode>> + > Parse3, - Grammar2 grammar, - IImmutableEnumerator tokens + IImmutableEnumerator tokens, + Grammar2 grammar ) => tokens .FirstAndRest() .Match( None: () => throw new Exception("EOF, what to do?"), - Some: headRest => { - var first = headRest.Item1; - var rest = headRest.Item2; + Some: firstRest => { + // Case("IImmutableEnumerable", "Operator")) + var first = firstRest.Item1; + var rest = firstRest.Item2; return grammar.Match( RepeatOnePlus: g => - Parse3(g, rest) - .IfSome(rest1 => - WhileSome(rest1, restI => Parse3(g, restI))), + rest.FoldMapWhileSome(restI => Parse3(restI, g)) + .If, IEnumerable>((restN, nodes) => nodes.Count() > 1) + .IfSome((restN, nodes) => (restN, AstNode.Operator(nodes))), + //.IfSome(rest1 => + // TODO: remove IfSome above (useless) && aggregate + // WhileSome(rest1, restI => Parse3(restI, g))), // 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 + l.First(g => Parse3(rest, g)), Sequence: l => - l.BindFold(rest, - (restI, g) => Parse3(g, restI)), + l.BindFoldMap(rest, (restI, g) => Parse3(restI, g)) + .IfSome((restN, nodes) => (restN, AstNode.Operator(nodes))), Terminal: t => first.state.Equals(t) - ? rest.Some() - : None>() + ? (rest, + AstNode.Terminal(/* TODO: */ Expr.String(rest.ToString()))) + .Some() + : None, AstNode>>() ); // TODO: at the top-level, check that the lexemes // are empty if the parser won't accept anything else. } ); + public static Option, AstNode>> Parse2(string source) { + Grammar2 grammar = + DefaultGrammar.DefaultPrecedenceDAG.ToGrammar2(); + Log(grammar.Str()); + + var P = Func.YMemoize< + IImmutableEnumerator, + Grammar2, + Option, AstNode>>>( + Parse3 + ); + + return P(Lexer.Lex(source), grammar); + } + public static Ast.Expr Parse(string source) { return Lexer.Lex(source) .SelectMany(lexeme => diff --git a/Utils/Enumerable.cs b/Utils/Enumerable.cs index bbb74ee..b30c652 100644 --- a/Utils/Enumerable.cs +++ b/Utils/Enumerable.cs @@ -239,17 +239,25 @@ public static class Collection { 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(); + var newAcc = f(acc, x); + if (newAcc.IsNone) { + break; } else { - acc = @new.ElseThrow(() => new Exception("impossible")); + acc = newAcc.ElseThrow(new Exception("impossible")); } } return acc.Some(); } - public static A WhileSome(this A init, Func> f) { + public static Option>> BindFoldMap(this IEnumerable e, A init, Func>> f) + => e.BindFold( + (init, ImmutableStack.Empty), + (accL, x) => + f(accL.Item1, x).IfSome((newAcc, result) => + (newAcc, accL.Item2.Push(result))) + ).IfSome((acc, l) => (acc, l.Reverse())); + + public static A FoldWhileSome(this A init, Func> f) { var lastGood = init; while (true) { var @new = f(lastGood); @@ -261,6 +269,17 @@ public static class Collection { } } - public static Option> WhileSome(this Option> init, Func>> f) - => init.IfSome(ab1 => WhileSome(ab1, ab => f(ab.Item1, ab.Item2))); + public static Option> FoldWhileSome(this Option> init, Func>> f) + => init.IfSome(ab1 => ab1.FoldWhileSome(ab => f(ab.Item1, ab.Item2))); + + public static Option> FoldWhileSome(this Option> init, Func>> f) + => init.IfSome(ab1 => ab1.FoldWhileSome(ab => f(ab.Item1, ab.Item2))); + + public static ValueTuple> FoldMapWhileSome(this A init, Func>> f) + => FoldWhileSome( + (init, ImmutableStack.Empty), + accL => + f(accL.Item1).IfSome((newAcc, result) => + (newAcc, accL.Item2.Push(result))) + ).Pipe((acc, l) => (acc, l.Reverse())); } \ No newline at end of file diff --git a/Utils/Global.cs b/Utils/Global.cs index 38fded5..5bcc04d 100644 --- a/Utils/Global.cs +++ b/Utils/Global.cs @@ -23,11 +23,11 @@ public static class Global { public static T To(this T x) => x; - public static A WhileSome(A init, Func> f) - => Collection.WhileSome(init, f); + public static A FoldWhileSome(A init, Func> f) + => Collection.FoldWhileSome(init, f); - public static Option> WhileSome(Option> init, Func>> f) - => Collection.WhileSome(init, f); + public static Option> FoldWhileSome(Option> init, Func>> f) + => Collection.FoldWhileSome(init, f); public static IImmutableEnumerator Empty() => ImmutableEnumeratorExtensionMethods.Empty(); diff --git a/Utils/Immutable/Option.cs b/Utils/Immutable/Option.cs index cd99719..d0b9b8b 100644 --- a/Utils/Immutable/Option.cs +++ b/Utils/Immutable/Option.cs @@ -64,9 +64,18 @@ namespace Immutable { public static Option IfSome(this Option o, Func some) => o.Map(some); + public static Option If(this T value, Func predicate) + => predicate(value) ? value.Some() : Option.None(); + + public static Option> If(this ValueTuple value, Func predicate) + => predicate(value.Item1, value.Item2) ? value.Some() : Option.None>(); + public static Option IfSome(this Option> o, Func some) => o.Map(o1o2 => some(o1o2.Item1, o1o2.Item2)); + public static Option IfSome(this Option> o, Func some) + => o.Map(o1o2 => some(o1o2.Item1, o1o2.Item2)); + public static Option Bind(this Option o, Func> f) => o.Match_(Some: some => f(some), None: () => Option.None()); diff --git a/Utils/Piping.cs b/Utils/Piping.cs index 12f45e4..13bf156 100644 --- a/Utils/Piping.cs +++ b/Utils/Piping.cs @@ -3,6 +3,7 @@ using System.Linq; public static class Piping { public static U Pipe(this T x, Func f) => f(x); + public static U Pipe(this ValueTuple x, Func f) => f(x.Item1, x.Item2); public static void Pipe(this T x, Action f) => f(x);